@noetic-tools/core 5.0.0 → 5.1.0

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

@@ -253,9 +253,12 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      * the same arrangement `executeLLM` builds: harness-level context layers'
      * recall outputs concatenated with the session's accumulated history.
      *
-     * Read-mostly: `recallLayers` writes layer-state snapshots to
-     * `layerStateStore` exactly as a real turn would, so successive previews
-     * remain consistent with what the next real turn produces.
+     * Runs layer `init` on the throwaway preview context first — exactly what
+     * the next real turn's `ensureLayersInit` would do, re-hydrating thread/
+     * resource-scoped state from storage. Without it, every init-bearing layer
+     * is treated as disabled by the recall lifecycle and the preview silently
+     * degenerates to bare history. The preview execution's store entries are
+     * dropped afterwards so repeated previews don't grow the layer-state store.
      */
     previewRequestItems(scope?: SessionScope): Promise<ReadonlyArray<Item>>;
     storeLayers(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<void>;

package/dist/harness/agent-harness.js

@@ -631,9 +631,12 @@ export class AgentHarness {
      * the same arrangement `executeLLM` builds: harness-level context layers'
      * recall outputs concatenated with the session's accumulated history.
      *
-     * Read-mostly: `recallLayers` writes layer-state snapshots to
-     * `layerStateStore` exactly as a real turn would, so successive previews
-     * remain consistent with what the next real turn produces.
+     * Runs layer `init` on the throwaway preview context first — exactly what
+     * the next real turn's `ensureLayersInit` would do, re-hydrating thread/
+     * resource-scoped state from storage. Without it, every init-bearing layer
+     * is treated as disabled by the recall lifecycle and the preview silently
+     * degenerates to bare history. The preview execution's store entries are
+     * dropped afterwards so repeated previews don't grow the layer-state store.
      */
     async previewRequestItems(scope) {
         const threadId = scope?.threadId ?? DEFAULT_THREAD_ID;
@@ -654,16 +657,24 @@ export class AgentHarness {
         if (layers.length === 0) {
             return historyItems;
         }
-        const recallResults = await this.recallLayers(layers, '', ctx);
-        const layerOutputItems = recallResults.flatMap((r) => r.items);
-        if (layerOutputItems.length === 0) {
-            return historyItems;
+        try {
+            await this.ensureLayersInit(ctx);
+            const recallResults = await this.recallLayers(layers, '', ctx);
+            const layerOutputItems = recallResults.flatMap((r) => r.items);
+            if (layerOutputItems.length === 0) {
+                return historyItems;
+            }
+            return assembleView({
+                systemPromptItems: [],
+                layerOutputItems,
+                historyItems,
+            });
+        }
+        finally {
+            await this.layerStateStore.flush?.(ctx.id);
+            this.layerStateStore.cleanup(ctx.id);
+            this.initializedExecutions.delete(ctx.id);
         }
-        return assembleView({
-            systemPromptItems: [],
-            layerOutputItems,
-            historyItems,
-        });
     }
     async storeLayers(layers, response, ctx) {
         const storage = this.config.storage;

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

@@ -34,6 +34,13 @@ export declare class AgentHarnessModelCaller {
     private readonly opts;
     constructor(opts: AgentHarnessModelCallerOpts);
     private newSpanCollector;
+    /**
+     * Broadcast a framework-authored item so `getItemStream` carries it — tool
+     * results and injected messages never appear in the SDK stream. Emitted
+     * unconditionally: item streaming, like the SDK item events, is not subject
+     * to `step.emit` filtering.
+     */
+    private emitItemAppended;
     private callOverriddenModel;
     private requireModelClient;
     callModel(request: CallModelRequest): Promise<LLMResponse>;

package/dist/harness/model-call.js

@@ -302,6 +302,22 @@ export class AgentHarnessModelCaller {
     newSpanCollector(request) {
         return new CallSpanCollector(this.opts.harness, this.opts.traceExporter, request.parentSpan ?? request.ctx?.span ?? null, request.nodeId);
     }
+    /**
+     * Broadcast a framework-authored item so `getItemStream` carries it — tool
+     * results and injected messages never appear in the SDK stream. Emitted
+     * unconditionally: item streaming, like the SDK item events, is not subject
+     * to `step.emit` filtering.
+     */
+    emitItemAppended(ctx, item) {
+        emitFrameworkEvent({
+            broadcaster: getBroadcaster(ctx),
+            agentName: this.opts.agentName,
+            eventType: 'item_appended',
+            data: {
+                item,
+            },
+        });
+    }
     async callOverriddenModel(request) {
         if (!this.opts.callModelOverride) {
             throw new Error('No callModel override configured.');
@@ -557,6 +573,7 @@ export class AgentHarnessModelCaller {
                 ],
             });
             ctx.itemLog.append(userItem);
+            this.emitItemAppended(ctx, userItem);
         }
         emitIfAllowed('inbox_injected', {
             round,
@@ -706,6 +723,7 @@ export class AgentHarnessModelCaller {
             callId: fc.callId,
             output: toolResult.output,
         });
+        this.emitItemAppended(request.ctx, outputItem);
         params.emitIfAllowed('tool_call_completed', {
             name: fc.name,
             callId: fc.callId,
@@ -731,6 +749,7 @@ export class AgentHarnessModelCaller {
             callId: fc.callId,
             output: errorOutput,
         });
+        this.emitItemAppended(request.ctx, outputItem);
         params.emitIfAllowed('tool_call_completed', {
             name: fc.name,
             callId: fc.callId,

package/dist/runtime/session-runner.js

@@ -174,6 +174,18 @@ export class SessionRunner {
                 messageIds: messages.map((m) => m.id),
             },
         });
+        // Input items never appear in the SDK stream — item_appended is what
+        // carries them into getItemStream (and any other log-faithful consumer).
+        for (const item of items) {
+            emitFrameworkEvent({
+                broadcaster: this.broadcaster,
+                agentName: this.agentName,
+                eventType: 'item_appended',
+                data: {
+                    item,
+                },
+            });
+        }
         const turn = {
             turnId,
             session: this,

package/dist/runtime/session-streams.d.ts

@@ -6,5 +6,9 @@ export declare function filterTextStream(broadcaster: EventBroadcaster): AsyncIt
 export declare function filterReasoningStream(broadcaster: EventBroadcaster): AsyncIterable<string>;
 /** @internal Yield cumulative StreamingItem snapshots. Uses roundOffset keyed by
  *  response.created so accumulators across multiple tool rounds and across
- *  multiple turns within a session don't collide. */
+ *  multiple turns within a session don't collide.
+ *
+ *  SDK events cover model output only; framework-authored items — turn input
+ *  messages, between-rounds injections, tool results — arrive via the
+ *  `item_appended` framework event and are yielded already complete. */
 export declare function buildItemStream(broadcaster: EventBroadcaster, itemSchemas?: ItemSchemaRegistry): AsyncIterable<StreamingItem>;

package/dist/runtime/session-streams.js

@@ -1,4 +1,4 @@
-import { defaultItemSchemaRegistry } from '@noetic-tools/types';
+import { defaultItemSchemaRegistry, frameworkCast } from '@noetic-tools/types';
 //#endregion
 //#region Helpers
 function isItemRecord(value) {
@@ -138,11 +138,26 @@ export async function* filterReasoningStream(broadcaster) {
 }
 /** @internal Yield cumulative StreamingItem snapshots. Uses roundOffset keyed by
  *  response.created so accumulators across multiple tool rounds and across
- *  multiple turns within a session don't collide. */
+ *  multiple turns within a session don't collide.
+ *
+ *  SDK events cover model output only; framework-authored items — turn input
+ *  messages, between-rounds injections, tool results — arrive via the
+ *  `item_appended` framework event and are yielded already complete. */
 export async function* buildItemStream(broadcaster, itemSchemas = defaultItemSchemaRegistry) {
     const accumulators = new Map();
     let roundOffset = 0;
     for await (const event of broadcaster) {
+        if (event.source === 'framework') {
+            if (event.type.endsWith(':item_appended') &&
+                typeof event.data.item === 'object' &&
+                event.data.item !== null) {
+                yield {
+                    ...frameworkCast(event.data.item),
+                    isComplete: true,
+                };
+            }
+            continue;
+        }
         if (event.source !== 'sdk') {
             continue;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/core",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "type": "module",
   "description": "Step primitives, interpreter, runtime, and context layer contract for Noetic agents.",
   "license": "Apache-2.0",