@noetic-tools/context 1.9.0 → 1.11.0

package/dist/context/layer-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { ContextLayer, DecisionRecord, ExecutionContext, Item, ItemLog, ItemSchemaRegistry, LLMResponse, ScopedStorage, SteeringDecision, StorageAdapter } from '@noetic-tools/types';
+import type { ContextLayer, DecisionRecord, ExecutionContext, Item, ItemLog, ItemSchemaRegistry, LLMResponse, OnSteerParams, ScopedStorage, SteeringDecision, SteerVerdict, StorageAdapter } from '@noetic-tools/types';
 import type { LiveChild } from './parent-updates.js';
 export interface LayerStateStore {
     get<T>(executionId: string, layerId: string): T | undefined;
@@ -154,6 +154,11 @@ interface AfterModelCallLayersParams {
     ctx: ExecutionContext;
     store: LayerStateStore;
 }
+interface OnSteerLayersParams extends Pick<OnSteerParams, 'steer' | 'point' | 'action' | 'pendingCalls'> {
+    layers: ContextLayer[];
+    ctx: ExecutionContext;
+    store: LayerStateStore;
+}
 interface ProjectHistoryLayersParams {
     layers: ContextLayer[];
     items: ReadonlyArray<Item>;
@@ -274,6 +279,13 @@ export declare function returnLayers<T>({ layers, stepId, parentCtx, childCtx, c
 export declare function completeLayers({ layers, ctx, log, outcome, store, }: CompleteLayersParams): Promise<void>;
 export declare function beforeToolCallLayers({ layers, toolName, toolArgs, callId, ctx, store, }: BeforeToolCallLayersParams): Promise<SteeringDecision>;
 export declare function afterModelCallLayers({ layers, response, ctx, store, }: AfterModelCallLayersParams): Promise<SteeringDecision>;
+/**
+ * Run a steer through every layer's `onSteer` hook in slot order. Each layer
+ * sees the action and items the previous layer left, so the last layer to
+ * speak wins. Any layer asking to recall is enough. A hook that throws or
+ * times out leaves the verdict unchanged.
+ */
+export declare function onSteerLayers({ layers, steer, point, action, pendingCalls, ctx, store, }: OnSteerLayersParams): Promise<SteerVerdict>;
 /**
  * Run history items through every layer's `projectHistory` hook in slot order.
  * Each layer receives the previous layer's output. Storage (`itemLog`) is

package/dist/context/layer-lifecycle.js

@@ -889,6 +889,72 @@ export async function afterModelCallLayers({ layers, response, ctx, store, }) {
     }
     return mostRestrictive(decisions);
 }
+/**
+ * Run a steer through every layer's `onSteer` hook in slot order. Each layer
+ * sees the action and items the previous layer left, so the last layer to
+ * speak wins. Any layer asking to recall is enough. A hook that throws or
+ * times out leaves the verdict unchanged.
+ */
+export async function onSteerLayers({ layers, steer, point, action, pendingCalls, ctx, store, }) {
+    const sorted = [
+        ...layers,
+    ].sort((a, b) => a.slot - b.slot);
+    let verdict = {
+        action,
+        items: steer.items,
+    };
+    for (const layer of sorted) {
+        if (!layer.hooks.onSteer) {
+            continue;
+        }
+        const state = store.get(ctx.executionId, layer.id);
+        if (isLayerDisabled({
+            store,
+            executionId: ctx.executionId,
+            layer,
+            state,
+        })) {
+            await traceSkipped(ctx, layer.id, 'onSteer');
+            continue;
+        }
+        const onSteer = layer.hooks.onSteer;
+        const current = verdict;
+        try {
+            const result = await callHook({
+                ctx,
+                layerId: layer.id,
+                hook: 'onSteer',
+                timeout: layer.timeouts?.onSteer ?? 5e3,
+                run: () => onSteer({
+                    steer: {
+                        id: steer.id,
+                        items: current.items,
+                    },
+                    point,
+                    action: current.action,
+                    pendingCalls,
+                    ctx,
+                    state,
+                }),
+            });
+            if (result.state !== undefined) {
+                store.set(ctx.executionId, layer.id, result.state);
+            }
+            verdict = {
+                action: result.action ?? current.action,
+                items: result.items ?? current.items,
+                recall: current.recall || result.recall,
+            };
+        }
+        catch (e) {
+            if (e instanceof NoeticConfigError) {
+                throw e;
+            }
+            store.diagnostic(layer.id, 'onSteer', e);
+        }
+    }
+    return verdict;
+}
 /**
  * Run history items through every layer's `projectHistory` hook in slot order.
  * Each layer receives the previous layer's output. Storage (`itemLog`) is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/context",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "type": "module",
   "description": "Context layer system for Noetic agents: the ContextLayer contract, lifecycle, budget/projection machinery, and built-in layer implementations.",
   "license": "Apache-2.0",
@@ -44,7 +44,7 @@
     "zod": "^4.0.0"
   },
   "dependencies": {
-    "@noetic-tools/types": "^3.10.0",
+    "@noetic-tools/types": "^3.15.0",
     "zod": "^4.0.0"
   },
   "scripts": {