@noetic-tools/core 5.7.0 → 5.9.0

package/dist/harness/agent-harness.d.ts

@@ -3,6 +3,7 @@ import { AcpSessionStore } from '../runtime/acp-session-store.js';
 import type { LayerStateStore, RecallCache } from './deps/context.js';
 import type { DetachedSpawnOverrides } from './deps/interpreter.js';
 import type { CheckpointStore, EventBroadcaster, RestoreCheckpointOptions, StepLedgerRetention, StepLedgerStore } from './deps/runtime.js';
+import { ChannelStore } from './deps/runtime.js';
 import type { AcpLiveSession, AcpSessionInfo, AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, ContextCacheConfig, ContextCacheStore, ContextData, ContextLayer, CwdState, DecideRequest, DecideResponse, DecisionRecord, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaConfig, LLMResponse, LlmProviderConfig, ProjectionPolicy, RecallLayerOutput, RecallOptions, SessionScope, SessionUsage, ShellAdapter, Span, SteeringDecision, Step, StorageAdapter, StreamEvent, StreamingItem, SubprocessAdapter, Tool, TraceExporter, ZodType } from './deps/types.js';
 export { createStreamIdleWatchdog } from './model-call.js';
 /**
@@ -163,9 +164,13 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     private readonly decideOverride?;
     /** Model id → whether it answers natively as a decision model. */
     private readonly decisionModels;
-    private readonly channelStore;
-    /** Re-entrant `run()` depth per root context id — see `executeClosingChannels`. */
-    private readonly rootRunDepth;
+    /** @internal Channel state; read by the checkpoint functions. */
+    readonly channelStore: ChannelStore;
+    /**
+     * Root contexts with a `run()` in flight, keyed by id, with their
+     * re-entrant run depth — see `executeClosingChannels`.
+     */
+    private readonly liveRoots;
     private readonly callModelOverride?;
     private readonly defaultDeliveryMode;
     private readonly sessions;
@@ -218,6 +223,12 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     private readonly initializedExecutions;
     /** Executions restored from a checkpoint: their first layer init keeps the restored state. */
     private readonly restoredExecutions;
+    /**
+     * Layer hooks still running per context. `cancel()` waits for them before
+     * `onComplete`/`dispose`, so teardown never races a half-finished `store`
+     * or `recall`. Each hook is bounded by its own timeout.
+     */
+    private readonly runningHooks;
     readonly traceExporter: TraceExporter;
     /**
      * Long-lived shared cwd state. The same reference is seeded into every
@@ -256,6 +267,13 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     decide(request: DecideRequest): Promise<DecideResponse>;
     notifyDecision(layers: ContextLayer[], record: DecisionRecord, ctx: Context): Promise<void>;
     run<I, O>(s: Step<ContextData, I, O>, input: I, ctx: Context): Promise<O>;
+    /**
+     * Whether `step` calls a model this harness has no credentials for. Checked
+     * before any step runs so a missing provider fails fast instead of after
+     * earlier steps' side effects. Steps the walk cannot see (dynamic branches)
+     * still hit the same error lazily at their model call.
+     */
+    private lacksModelFor;
     /** Run all layer `init` hooks before the first step executes. Per spec 11,
      *  init MUST complete before any recall fires so layer state is populated. */
     private initAndRun;
@@ -296,11 +314,11 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
         cwdInit?: string;
         _broadcaster?: EventBroadcaster;
     }): Context;
-    send<T>(channel: Channel<T>, value: T, ctx: Context): Promise<void>;
+    send<T>(channel: Channel<T>, value: NoInfer<T>, ctx: Context): Promise<void>;
     recv<T>(channel: Channel<T>, ctx: Context, opts?: {
         timeout?: number;
     }): Promise<T>;
-    tryRecv<T>(channel: Channel<T>, _ctx: Context): T | null;
+    tryRecv<T>(channel: Channel<T>, ctx: Context): T | null;
     getChannelHandle<T>(channel: ExternalChannel<T>, executionId: string): ChannelHandle<T>;
     getChannelStream<T>(channel: ExternalChannel<T>, executionId: string): AsyncIterable<T>;
     /** Resolves layer-provided tools and merges with step tools into ctx.unifiedTools. */
@@ -348,8 +366,11 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      */
     checkpoint(ctx: Context): Promise<void>;
     /**
-     * Rebuild a `Context` from a previously-persisted snapshot. Returns `null`
-     * if no snapshot is recorded for `executionId`. Surface a typed
+     * Rebuild a `Context` from what a previous run of `executionId` recorded: its
+     * checkpoint snapshot, its step-completion ledger, or both. Without a snapshot the
+     * context starts empty (no item log or layer state) but keeps the execution id and
+     * ledger, so recorded steps replay and the rest run fresh. Returns `null` when
+     * neither is recorded — start a fresh execution. Surface a typed
      * `NoeticConfigError(CHECKPOINT_SCHEMA_MISMATCH)` when the snapshot's
      * schema version is unrecognised — the caller is expected to discard the
      * checkpoint via `CheckpointStore.clear()` and start a fresh execution.
@@ -396,22 +417,33 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      * `cancelled`.
      *
      * Cancellation is cooperative: a layer hook already in flight is allowed to
-     * settle, and step code that ignores `ctx.aborted` between `await`s runs to
+     * settle (up to its timeout) before that context's teardown, and step code that ignores `ctx.aborted` between `await`s runs to
      * its next boundary. Calling `cancel()` on an already-cancelled context is a
      * no-op.
      */
     cancel(ctx: Context, reason?: string): Promise<void>;
     /**
-     * Run the layer lifecycle's abort path for one cancelled context:
-     * `onComplete` with `outcome: 'aborted'`, then `dispose`. Both always run
-     * under cancellation (spec 09, Cancellation item 5).
+     * Run the layer lifecycle's abort path for one cancelled context: wait for
+     * its in-flight layer hooks to settle, then `onComplete` with
+     * `outcome: 'aborted'`, then `dispose`. Both always run under cancellation
+     * (spec 09, Cancellation item 6).
      */
     private teardownCancelledContext;
+    /**
+     * Channel state is shared by every root on this harness, so a channel
+     * warning is recorded as a `channel.warning` event on each live root's
+     * span (spec 10). A root span counts only if it will reach the trace
+     * exporter — a harness span (`SpanImpl`) with a real exporter configured.
+     * With no such span the warning goes to the console, so it is never lost.
+     */
+    private recordChannelWarning;
     createSpan(name: string, parent: Span | null): Span;
     getLayerState<T>(executionId: string, layerId: string): T | undefined;
     setLayerState<T>(executionId: string, layerId: string, state: T): void;
     beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context, callId?: string): Promise<SteeringDecision>;
     afterModelCall(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
+    /** Record `hook` as running on `ctx` until it settles (see `runningHooks`). */
+    private trackHook;
     projectHistory(layers: ContextLayer[], items: ReadonlyArray<Item>, ctx: Context): Promise<ReadonlyArray<Item>>;
     runAppendPipeline(layers: ContextLayer[], items: Item[], ctx: Context): Promise<{
         items: Item[];

package/dist/harness/agent-harness.js

@@ -1,14 +1,15 @@
 import { frameworkCast, ItemSchemaRegistry, NoeticConfigError } from '@noetic-tools/types';
+import { NoeticEvent } from '../observability/genai-attributes.js';
 import { SpanImpl } from '../observability/span-impl.js';
 import { NoopExporter } from '../observability/trace-exporter.js';
 import { AcpSessionStore } from '../runtime/acp-session-store.js';
 import { callDecide } from './decide-call.js';
 import { createInMemoryFsAdapter, createInMemoryShellAdapter, createInMemorySubprocessAdapter, OpenRouter, OpenRouterSdk, } from './deps/adapters.js';
 import { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createContextCacheStore, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, notifyDecision, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from './deps/context.js';
-import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, prepareBandedView, } from './deps/interpreter.js';
-import { buildItemStream, ChannelStore, ContextImpl, captureCheckpoint, clearCheckpoint, collectContextTree, createInMemoryStorage, createStepLedgerStore, filterReasoningStream, filterTextStream, resolveStepLedgerRetention, restoreFromCheckpoint, SessionRunner, StepLedger, snapshotCwdState, } from './deps/runtime.js';
+import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, prepareBandedView, someStep, } from './deps/interpreter.js';
+import { buildItemStream, ChannelStore, ContextImpl, captureCheckpoint, clearCheckpoint, collectContextTree, createInMemoryStorage, createStepLedgerStore, filterReasoningStream, filterTextStream, resolveStepLedgerRetention, restoreFromCheckpoint, rootIdOf, SessionRunner, StepLedger, snapshotCwdState, warnToConsole, } from './deps/runtime.js';
 import { SteeringAction } from './deps/types.js';
-import { AgentHarnessModelCaller } from './model-call.js';
+import { AgentHarnessModelCaller, noLlmProviderError } from './model-call.js';
 export { createStreamIdleWatchdog } from './model-call.js';
 import { buildItemSchemaRegistry } from './model-schema.js';
 //#endregion
@@ -202,9 +203,13 @@ export class AgentHarness {
     decideOverride;
     /** Model id → whether it answers natively as a decision model. */
     decisionModels = new Map();
+    /** @internal Channel state; read by the checkpoint functions. */
     channelStore;
-    /** Re-entrant `run()` depth per root context id — see `executeClosingChannels`. */
-    rootRunDepth = new Map();
+    /**
+     * Root contexts with a `run()` in flight, keyed by id, with their
+     * re-entrant run depth — see `executeClosingChannels`.
+     */
+    liveRoots = new Map();
     callModelOverride;
     defaultDeliveryMode;
     sessions = new Map();
@@ -270,6 +275,12 @@ export class AgentHarness {
     initializedExecutions = new Set();
     /** Executions restored from a checkpoint: their first layer init keeps the restored state. */
     restoredExecutions = new Set();
+    /**
+     * Layer hooks still running per context. `cancel()` waits for them before
+     * `onComplete`/`dispose`, so teardown never races a half-finished `store`
+     * or `recall`. Each hook is bounded by its own timeout.
+     */
+    runningHooks = new WeakMap();
     traceExporter;
     /**
      * Long-lived shared cwd state. The same reference is seeded into every
@@ -317,7 +328,9 @@ export class AgentHarness {
         this.decisionsClient = opts._testCallModel
             ? undefined
             : createDecisionsClient(opts.callModelDefaults);
-        this.channelStore = new ChannelStore();
+        this.channelStore = new ChannelStore({
+            onWarning: (warning) => this.recordChannelWarning(warning),
+        });
         this.traceExporter = opts.traceExporter ?? new NoopExporter();
         this.layerStateStore =
             storageEnv?.layerStateStore ??
@@ -356,6 +369,9 @@ export class AgentHarness {
                 hint: 'Pass `agentGraph` in constructor options, or use run() directly.',
             }));
         }
+        if (this.lacksModelFor(this.agentGraph)) {
+            return Promise.reject(noLlmProviderError());
+        }
         const threadId = options?.threadId ?? DEFAULT_THREAD_ID;
         const deliveryMode = options?.deliveryMode ?? this.defaultDeliveryMode;
         const session = this.getOrCreateSession(threadId);
@@ -545,16 +561,19 @@ export class AgentHarness {
         });
     }
     async notifyDecision(layers, record, ctx) {
-        await notifyDecision({
+        await this.trackHook(ctx, notifyDecision({
             layers,
             record,
             ctx: this.toExecCtx(ctx),
             store: this.layerStateStore,
             recallCache: this.recallCache,
-        });
+        }));
     }
     //#endregion
     async run(s, input, ctx) {
+        if (this.lacksModelFor(s)) {
+            throw noLlmProviderError();
+        }
         // Populate the unified tool pool when an embedder drives a step directly on
         // a bare `createContext()` context (the turn pipeline does this per turn).
         // Without it, steps that resolve tools dynamically from `ctx.unifiedTools`
@@ -571,6 +590,18 @@ export class AgentHarness {
         await this.ensureLayersInit(ctx);
         return this.executeClosingChannels(s, input, ctx);
     }
+    /**
+     * Whether `step` calls a model this harness has no credentials for. Checked
+     * before any step runs so a missing provider fails fast instead of after
+     * earlier steps' side effects. Steps the walk cannot see (dynamic branches)
+     * still hit the same error lazily at their model call.
+     */
+    lacksModelFor(step) {
+        if (this.client || this.callModelOverride) {
+            return false;
+        }
+        return someStep(frameworkCast(step), (s) => s.kind === 'callModel' || (s.kind === 'decide' && !this.decideOverride));
+    }
     /** Run all layer `init` hooks before the first step executes. Per spec 11,
      *  init MUST complete before any recall fires so layer state is populated. */
     async initAndRun(s, input, ctx) {
@@ -589,23 +620,25 @@ export class AgentHarness {
         if (ctx.parent !== null) {
             return execute(s, input, ctx);
         }
-        const depth = this.rootRunDepth.get(ctx.id) ?? 0;
-        if (depth === 0) {
+        const live = this.liveRoots.get(ctx.id);
+        if (!live) {
             // A restored or sequentially re-run root context reuses its id — clear
             // any closure from a previous completion so its channels work again.
             this.channelStore.openExecution(ctx.id);
         }
-        this.rootRunDepth.set(ctx.id, depth + 1);
+        const entry = live ?? {
+            ctx,
+            depth: 0,
+        };
+        entry.depth += 1;
+        this.liveRoots.set(ctx.id, entry);
         try {
             return await execute(s, input, ctx);
         }
         finally {
-            const remaining = (this.rootRunDepth.get(ctx.id) ?? 1) - 1;
-            if (remaining > 0) {
-                this.rootRunDepth.set(ctx.id, remaining);
-            }
-            else {
-                this.rootRunDepth.delete(ctx.id);
+            entry.depth -= 1;
+            if (entry.depth <= 0) {
+                this.liveRoots.delete(ctx.id);
                 this.channelStore.closeExecution(ctx.id);
                 await this.acpSessions.closeOwnedBy(ctx.id);
             }
@@ -688,6 +721,7 @@ export class AgentHarness {
         // Internal sender: back-pressured on full queue channels. The calling
         // context's abort signal rejects a parked send with 'cancelled'.
         const signal = ctx instanceof ContextImpl ? ctx.abortSignal : undefined;
+        this.channelStore.claim(channel, rootIdOf(ctx));
         return this.channelStore.send(channel, value, {
             signal,
         });
@@ -696,9 +730,11 @@ export class AgentHarness {
         // Wire the calling context's abort signal so ctx.abort() rejects a
         // pending recv with { kind: 'cancelled' } instead of hanging.
         const signal = ctx instanceof ContextImpl ? ctx.abortSignal : undefined;
+        this.channelStore.claim(channel, rootIdOf(ctx));
         return this.channelStore.recv(channel, opts?.timeout, signal);
     }
-    tryRecv(channel, _ctx) {
+    tryRecv(channel, ctx) {
+        this.channelStore.claim(channel, rootIdOf(ctx));
         return this.channelStore.tryRecv(channel);
     }
     getChannelHandle(channel, executionId) {
@@ -734,7 +770,7 @@ export class AgentHarness {
         });
     }
     async recallLayers(layers, input, ctx) {
-        return recallLayers({
+        return this.trackHook(ctx, recallLayers({
             layers,
             query: input,
             ctx: this.toExecCtx(ctx),
@@ -742,7 +778,7 @@ export class AgentHarness {
             budgets: this.layerBudgets(layers),
             store: this.layerStateStore,
             itemSchemas: this.itemSchemas,
-        });
+        }));
     }
     /** Allocate per-layer recall budgets from the harness projection policy. */
     layerBudgets(layers) {
@@ -759,7 +795,7 @@ export class AgentHarness {
         ]));
     }
     async recallLayersAtomic(layers, input, ctx, budgets, opts) {
-        return recallLayersAtomic({
+        return this.trackHook(ctx, recallLayersAtomic({
             layers,
             query: input,
             ctx: this.toExecCtx(ctx),
@@ -769,10 +805,10 @@ export class AgentHarness {
             itemSchemas: this.itemSchemas,
             forceAtomic: this.config.forceAtomicRecall,
             peek: opts?.peek,
-        });
+        }));
     }
     async recallLayersEventual(layers, input, ctx, budgets, opts) {
-        return recallLayersEventual({
+        return this.trackHook(ctx, recallLayersEventual({
             layers,
             query: input,
             ctx: this.toExecCtx(ctx),
@@ -783,7 +819,7 @@ export class AgentHarness {
             forceAtomic: this.config.forceAtomicRecall,
             cache: this.recallCache,
             peek: opts?.peek,
-        });
+        }));
     }
     /**
      * Compute the items array that would be sent to the model on the next turn —
@@ -858,7 +894,7 @@ export class AgentHarness {
         if (!storage) {
             return;
         }
-        await storeLayers({
+        await this.trackHook(ctx, storeLayers({
             layers,
             response,
             ctx: this.toExecCtx(ctx),
@@ -866,7 +902,7 @@ export class AgentHarness {
             store: this.layerStateStore,
             storage,
             recallCache: this.recallCache,
-        });
+        }));
     }
     async disposeLayers(layers, ctx) {
         // Drop the init guard so a deliberate dispose→run cycle re-hydrates from
@@ -902,8 +938,11 @@ export class AgentHarness {
         return captureCheckpoint(this, ctx);
     }
     /**
-     * Rebuild a `Context` from a previously-persisted snapshot. Returns `null`
-     * if no snapshot is recorded for `executionId`. Surface a typed
+     * Rebuild a `Context` from what a previous run of `executionId` recorded: its
+     * checkpoint snapshot, its step-completion ledger, or both. Without a snapshot the
+     * context starts empty (no item log or layer state) but keeps the execution id and
+     * ledger, so recorded steps replay and the rest run fresh. Returns `null` when
+     * neither is recorded — start a fresh execution. Surface a typed
      * `NoeticConfigError(CHECKPOINT_SCHEMA_MISMATCH)` when the snapshot's
      * schema version is unrecognised — the caller is expected to discard the
      * checkpoint via `CheckpointStore.clear()` and start a fresh execution.
@@ -921,11 +960,14 @@ export class AgentHarness {
      * whose `id` is already the original `executionId`.
      */
     async restore(executionId, opts) {
-        const ctx = await restoreFromCheckpoint(this, executionId, opts);
-        if (ctx) {
-            this.restoredExecutions.add(ctx.id);
+        const restored = await restoreFromCheckpoint(this, executionId, opts);
+        if (!restored) {
+            return null;
+        }
+        if (restored.fromSnapshot) {
+            this.restoredExecutions.add(executionId);
         }
-        return ctx;
+        return restored.ctx;
     }
     /**
      * Discard everything `restore(executionId)` would have used — the snapshot *and* the
@@ -959,7 +1001,7 @@ export class AgentHarness {
      * `cancelled`.
      *
      * Cancellation is cooperative: a layer hook already in flight is allowed to
-     * settle, and step code that ignores `ctx.aborted` between `await`s runs to
+     * settle (up to its timeout) before that context's teardown, and step code that ignores `ctx.aborted` between `await`s runs to
      * its next boundary. Calling `cancel()` on an already-cancelled context is a
      * no-op.
      */
@@ -981,15 +1023,17 @@ export class AgentHarness {
         }
     }
     /**
-     * Run the layer lifecycle's abort path for one cancelled context:
-     * `onComplete` with `outcome: 'aborted'`, then `dispose`. Both always run
-     * under cancellation (spec 09, Cancellation item 5).
+     * Run the layer lifecycle's abort path for one cancelled context: wait for
+     * its in-flight layer hooks to settle, then `onComplete` with
+     * `outcome: 'aborted'`, then `dispose`. Both always run under cancellation
+     * (spec 09, Cancellation item 6).
      */
     async teardownCancelledContext(ctx) {
         const layers = ctx.layers ?? [];
         if (layers.length === 0) {
             return;
         }
+        await Promise.allSettled(this.runningHooks.get(ctx) ?? []);
         await completeLayers({
             layers: [
                 ...layers,
@@ -1003,6 +1047,29 @@ export class AgentHarness {
             ...layers,
         ], ctx);
     }
+    /**
+     * Channel state is shared by every root on this harness, so a channel
+     * warning is recorded as a `channel.warning` event on each live root's
+     * span (spec 10). A root span counts only if it will reach the trace
+     * exporter — a harness span (`SpanImpl`) with a real exporter configured.
+     * With no such span the warning goes to the console, so it is never lost.
+     */
+    recordChannelWarning(warning) {
+        const traced = this.traceExporter instanceof NoopExporter
+            ? []
+            : [
+                ...this.liveRoots.values(),
+            ].filter(({ ctx }) => ctx.span instanceof SpanImpl);
+        if (traced.length === 0) {
+            warnToConsole(warning);
+            return;
+        }
+        for (const { ctx } of traced) {
+            ctx.span.addEvent(NoeticEvent.CHANNEL_WARNING, {
+                ...warning,
+            });
+        }
+    }
     createSpan(name, parent) {
         return new SpanImpl(name, parent);
     }
@@ -1019,14 +1086,14 @@ export class AgentHarness {
                 action: SteeringAction.Allow,
             };
         }
-        return beforeToolCallLayers({
+        return this.trackHook(ctx, beforeToolCallLayers({
             layers,
             toolName,
             toolArgs,
             callId,
             ctx: this.toExecCtx(ctx),
             store: this.layerStateStore,
-        });
+        }));
     }
     async afterModelCall(layers, response, ctx) {
         const hasHook = layers.some((l) => l.hooks.afterModelCall);
@@ -1035,12 +1102,26 @@ export class AgentHarness {
                 action: SteeringAction.Allow,
             };
         }
-        return afterModelCallLayers({
+        return this.trackHook(ctx, afterModelCallLayers({
             layers,
             response,
             ctx: this.toExecCtx(ctx),
             store: this.layerStateStore,
-        });
+        }));
+    }
+    /** Record `hook` as running on `ctx` until it settles (see `runningHooks`). */
+    trackHook(ctx, hook) {
+        let running = this.runningHooks.get(ctx);
+        if (!running) {
+            running = new Set();
+            this.runningHooks.set(ctx, running);
+        }
+        running.add(hook);
+        const forget = () => {
+            running.delete(hook);
+        };
+        hook.then(forget, forget);
+        return hook;
     }
     async projectHistory(layers, items, ctx) {
         const hasHook = layers.some((l) => l.hooks.projectHistory);

package/dist/harness/deps/interpreter.d.ts

@@ -3,4 +3,5 @@ export { prepareBandedView } from '../../interpreter/context-assembly.js';
 export { execute } from '../../interpreter/execute.js';
 export type { DetachedSpawnOverrides } from '../../interpreter/step-dispatcher.js';
 export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher.js';
+export { someStep } from '../../interpreter/step-walk.js';
 export { isFunctionCall } from '../../interpreter/typeguards.js';

package/dist/harness/deps/interpreter.js

@@ -2,4 +2,5 @@ export { collectAllTools, deduplicateTools } from '../../interpreter/collect-too
 export { prepareBandedView } from '../../interpreter/context-assembly.js';
 export { execute } from '../../interpreter/execute.js';
 export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher.js';
+export { someStep } from '../../interpreter/step-walk.js';
 export { isFunctionCall } from '../../interpreter/typeguards.js';

package/dist/harness/deps/runtime.d.ts

@@ -1,5 +1,6 @@
-export { ChannelStore } from '../../runtime/channel-store.js';
-export { ContextImpl, collectContextTree } from '../../runtime/context-impl.js';
+export type { ChannelWarning } from '../../runtime/channel-store.js';
+export { ChannelStore, warnToConsole } from '../../runtime/channel-store.js';
+export { ContextImpl, collectContextTree, rootIdOf } from '../../runtime/context-impl.js';
 export { snapshotCwdState } from '../../runtime/cwd-helpers.js';
 export type { CheckpointStore } from '../../runtime/durable/index.js';
 export type { RestoreCheckpointOptions } from '../../runtime/durable/harness-checkpoints.js';

package/dist/harness/deps/runtime.js

@@ -1,5 +1,5 @@
-export { ChannelStore } from '../../runtime/channel-store.js';
-export { ContextImpl, collectContextTree } from '../../runtime/context-impl.js';
+export { ChannelStore, warnToConsole } from '../../runtime/channel-store.js';
+export { ContextImpl, collectContextTree, rootIdOf } from '../../runtime/context-impl.js';
 export { snapshotCwdState } from '../../runtime/cwd-helpers.js';
 export { captureCheckpoint, clearCheckpoint, restoreFromCheckpoint, } from '../../runtime/durable/harness-checkpoints.js';
 export { createStepLedgerStore, resolveStepLedgerRetention, StepLedger, } from '../../runtime/durable/step-ledger.js';

package/dist/harness/model-call.d.ts

@@ -1,4 +1,5 @@
 import type { AgentHarnessContract, CallModelRequest, ItemSchemaRegistry, LLMResponse, TraceExporter } from '@noetic-tools/types';
+import { NoeticConfigError } from '@noetic-tools/types';
 import type { OpenRouter } from '@openrouter/agent';
 import type { MessageQueue } from '../runtime/message-queue.js';
 interface StreamIdleWatchdog {
@@ -7,6 +8,8 @@ interface StreamIdleWatchdog {
     /** Clear the pending timer. Safe to call multiple times. */
     stop: () => void;
 }
+/** @internal The error for a model call on a harness with no LLM credentials. */
+export declare function noLlmProviderError(): NoeticConfigError;
 /** @internal Create a watchdog that aborts `controller` when no
  *  {@link StreamIdleWatchdog.reset reset} is called within `timeoutMs`. When
  *  `timeoutMs <= 0`, returns an inert no-op so callers can always call `.reset()`

package/dist/harness/model-call.js

@@ -133,6 +133,14 @@ async function pipeStreamEventsToBroadcaster(opts) {
         throw err;
     }
 }
+/** @internal The error for a model call on a harness with no LLM credentials. */
+export function noLlmProviderError() {
+    return new NoeticConfigError({
+        code: 'NO_LLM_PROVIDER',
+        message: 'No LLM provider configured on this harness.',
+        hint: 'Pass `callModelDefaults: { apiKey: "..." }` (defaults to the Noetic platform) or set NOETIC_API_KEY. For direct OpenRouter, use `callModelDefaults: { provider: "openrouter", apiKey: "..." }` or set OPENROUTER_API_KEY.',
+    });
+}
 /** @internal Create a watchdog that aborts `controller` when no
  *  {@link StreamIdleWatchdog.reset reset} is called within `timeoutMs`. When
  *  `timeoutMs <= 0`, returns an inert no-op so callers can always call `.reset()`
@@ -354,11 +362,7 @@ export class AgentHarnessModelCaller {
         if (this.opts.client) {
             return this.opts.client;
         }
-        throw new NoeticConfigError({
-            code: 'NO_LLM_PROVIDER',
-            message: 'No LLM provider configured on this harness.',
-            hint: 'Pass `callModelDefaults: { apiKey: "..." }` (defaults to the Noetic platform) or set NOETIC_API_KEY. For direct OpenRouter, use `callModelDefaults: { provider: "openrouter", apiKey: "..." }` or set OPENROUTER_API_KEY.',
-        });
+        throw noLlmProviderError();
     }
     async callModel(request) {
         if (this.opts.callModelOverride) {
@@ -386,6 +390,7 @@ export class AgentHarnessModelCaller {
         // the assembled view was cached (see `noteCacheOutcome`).
         const rounds = [];
         let totalCost = 0;
+        let servedTier;
         const conversationInput = itemsToInput(prepared.remaining);
         const textFormat = request.outputSchema
             ? buildTextFormat(request.outputSchema, request.outputJsonSchema)
@@ -434,6 +439,9 @@ export class AgentHarnessModelCaller {
                 temperature: request.params?.temperature,
                 maxOutputTokens: request.params?.maxTokens,
                 topP: request.params?.topP,
+                // The agent's bundled SDK types an older tier list (no `fast` or
+                // `ultrafast`); the field is an open enum, so newer tiers pass through.
+                serviceTier: frameworkCast(request.params?.serviceTier),
                 ...(textFormat
                     ? {
                         text: textFormat,
@@ -524,6 +532,7 @@ export class AgentHarnessModelCaller {
             totalUsage.outputTokens += roundUsage.outputTokens;
             totalUsage.cachedTokens += roundUsage.cachedTokens ?? 0;
             totalCost += roundCost;
+            servedTier = sdkResponse.serviceTier ?? undefined;
             allItems.push(...roundItems);
             const functionCalls = roundItems.filter(isFunctionCall);
             if (functionCalls.length === 0 || !request.tools) {
@@ -563,6 +572,11 @@ export class AgentHarnessModelCaller {
             },
             rounds,
             cost: totalCost > 0 ? totalCost : undefined,
+            ...(servedTier
+                ? {
+                    serviceTier: servedTier,
+                }
+                : {}),
         };
     }
     injectBetweenRoundMessages(ctx, conversationInput, round, emitIfAllowed) {

package/dist/index.d.ts

@@ -15,6 +15,8 @@ export { channel } from './builders/channel-builder.js';
 /** @public */
 export { context } from './builders/context-builder.js';
 /** @public */
+export type { ConditionalOpts, InParallelOpts } from './builders/control-flow-builders.js';
+/** @public */
 export { conditional, inParallel } from './builders/control-flow-builders.js';
 /** @public */
 export { decide, routeSwitch } from './builders/decide-builders.js';
@@ -84,7 +86,7 @@ export { DECISION_PROJECTION, decisionsHistoryLayer, filesystem, findFunctionCal
 /** @public */
 export { createMessage, estimateTokens, recordUsage } from '@noetic-tools/types';
 /** @public */
-export { GenAI, NoeticAttr, ToolAttr } from './observability/genai-attributes.js';
+export { GenAI, NoeticAttr, NoeticEvent, ToolAttr } from './observability/genai-attributes.js';
 /** @public */
 export { InMemoryExporter, NoopExporter } from './observability/trace-exporter.js';
 /** @public */
@@ -115,7 +117,7 @@ export type { Channel, ChannelHandle, ExternalChannel } from '@noetic-tools/type
 /** @public */
 export type { InferSchemaInput, InferSchemaOutput, InputSchemaConfig, LLMResponse, LlmProviderConfig, ModelParams, RetryPolicy, RoundUsage, SchemaValidationFailure, SchemaValidationResult, SchemaValidationSuccess, ServerToolSpec, StandardJSONSchemaV1, StandardSchemaV1, StepMeta, TokenUsage, Tool, ToolContextDeclaration, UsageCharge, } from '@noetic-tools/types';
 /** @public */
-export { isServerToolSpec, isStandardJsonSchema, isZodSchema, standardIssuesToZodError, validateSchema, } from '@noetic-tools/types';
+export { isServerToolSpec, isStandardJsonSchema, isZodSchema, ServiceTier, standardIssuesToZodError, validateSchema, } from '@noetic-tools/types';
 /** @public */
 /** @public */
 /** @public */
@@ -129,9 +131,9 @@ export { DetachedStatus } from '@noetic-tools/types';
 /** @public */
 export type { EmbedFn } from './types/embed.js';
 /** @public */
-export type { CheckpointSnapshot, CwdSnapshot, FrontierFrame, ItemLogSnapshot, PendingAskUserSnapshot, } from './types/checkpoint.js';
+export type { ChannelSnapshot, CheckpointSnapshot, CwdSnapshot, FrontierFrame, ItemLogSnapshot, PendingAskUserSnapshot, } from './types/checkpoint.js';
 /** @public */
-export { CheckpointSchemaVersion, CheckpointSnapshotSchema, CwdSnapshotSchema, FrontierFrameSchema, ItemLogSnapshotSchema, PendingAskUserSnapshotSchema, } from './types/checkpoint.js';
+export { ChannelSnapshotSchema, CheckpointSchemaVersion, CheckpointSnapshotSchema, CwdSnapshotSchema, FrontierFrameSchema, ItemLogSnapshotSchema, PendingAskUserSnapshotSchema, } from './types/checkpoint.js';
 /** @public */
 export type { NoeticError } from '@noetic-tools/types';
 /** @public */
@@ -153,7 +155,7 @@ export type { AfterModelCallParams, AfterModelCallResult, BeforeToolCallParams,
 /** @public */
 export { LedgerEntryKind, SteeringAction } from '@noetic-tools/types';
 /** @public */
-export type { ExecuteStepFn, SettleResult, Snapshot, Step, StepAcpAgent, StepCallModel, StepConditional, StepInParallel, StepInParallelAll, StepInParallelRace, StepInParallelSettle, StepInvokeTool, StepLoop, StepRunCode, StepSpawn, StepWithContext, Until, Verdict, } from '@noetic-tools/types';
+export type { ExecuteStepFn, MergeFn, SettleResult, Snapshot, Step, StepAcpAgent, StepCallModel, StepConditional, StepInParallel, StepInParallelAll, StepInParallelRace, StepInParallelSettle, StepInvokeTool, StepLoop, StepReplay, StepRunCode, StepSpawn, StepWithContext, Until, Verdict, } from '@noetic-tools/types';
 /** @public */
 export type { AnsweredAll, AnswerFor, BooleanAnswer, BooleanQuestion, CaseKeyOf, ChoiceAnswer, ChoiceQuestion, ChoiceValues, DecideAnswer, DecideAnswers, DecideQuestion, DecideQuestions, DecideRequest, DecideResponse, DecideStatePart, DecideStep, DecideView, DecisionMeta, DecisionRecord, DecisionSource, LevelLabels, OnDecisionParams, RecallOptions, ScoreAnswer, ScoreLevel, ScoreQuestion, StepDecide, } from '@noetic-tools/types';
 /** @public */