@noetic-tools/core 0.3.0 → 1.1.0

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

@@ -152,8 +152,8 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
         cwdInit?: string;
         _broadcaster?: EventBroadcaster;
     }): Context;
-    send<T>(channel: Channel<T>, value: T, _ctx: Context): void;
-    recv<T>(channel: Channel<T>, _ctx: Context, opts?: {
+    send<T>(channel: Channel<T>, value: 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;

package/dist/harness/agent-harness.js

@@ -137,7 +137,11 @@ export class AgentHarness {
         this.client = opts._testCallModel ? undefined : createClient(opts.llm);
         this.channelStore = new ChannelStore();
         this.traceExporter = opts.traceExporter ?? new NoopExporter();
-        this.layerStateStore = opts.layerStateStore ?? createLayerStateStore();
+        this.layerStateStore =
+            opts.layerStateStore ??
+                createLayerStateStore((layerId, hook, error) => {
+                    console.warn(`[noetic] memory layer '${layerId}' ${hook} error:`, error);
+                });
         this.recallCache = createRecallCache();
         this.defaultDeliveryMode = opts.defaultDeliveryMode ?? 'next-turn';
         this.streamIdleTimeoutMs = opts.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
@@ -366,11 +370,19 @@ export class AgentHarness {
             cwdState: resolveContextCwdState(this.rootCwdState, opts?.parent, cwdInit),
         });
     }
-    send(channel, value, _ctx) {
-        this.channelStore.send(channel, value);
+    send(channel, value, ctx) {
+        // 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;
+        return this.channelStore.send(channel, value, {
+            signal,
+        });
     }
-    recv(channel, _ctx, opts) {
-        return this.channelStore.recv(channel, opts?.timeout);
+    recv(channel, ctx, opts) {
+        // 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;
+        return this.channelStore.recv(channel, opts?.timeout, signal);
     }
     tryRecv(channel, _ctx) {
         return this.channelStore.tryRecv(channel);

package/dist/harness/model-call.js

@@ -400,7 +400,6 @@ export class AgentHarnessModelCaller {
             await this.executeToolRound({
                 functionCalls,
                 request,
-                roundItemSchemas,
                 allItems,
                 conversationInput,
                 round,
@@ -517,7 +516,7 @@ export class AgentHarnessModelCaller {
         };
     }
     async executeToolRound(params) {
-        const { functionCalls, request, roundItemSchemas, allItems, conversationInput } = params;
+        const { functionCalls, request, allItems, conversationInput } = params;
         params.emitIfAllowed('tool_round_started', {
             round: params.round,
             toolCount: functionCalls.length,
@@ -538,7 +537,6 @@ export class AgentHarnessModelCaller {
             await this.executeFunctionCall({
                 fc,
                 request,
-                roundItemSchemas,
                 allItems,
                 conversationInput,
                 emitIfAllowed: params.emitIfAllowed,
@@ -550,7 +548,7 @@ export class AgentHarnessModelCaller {
         });
     }
     async executeFunctionCall(params) {
-        const { fc, request, roundItemSchemas, allItems, conversationInput } = params;
+        const { fc, request, allItems, conversationInput } = params;
         params.emitIfAllowed('tool_call_started', {
             name: fc.name,
             callId: fc.callId,
@@ -563,7 +561,6 @@ export class AgentHarnessModelCaller {
             this.recordMalformedToolCall({
                 fc,
                 request,
-                roundItemSchemas,
                 allItems,
                 conversationInput,
                 emitIfAllowed: params.emitIfAllowed,
@@ -582,10 +579,13 @@ export class AgentHarnessModelCaller {
             harness: this.opts.harness,
             layers: request.layers,
         });
+        // Owner-scoped result validation: a tool's `toolResults` schemas apply
+        // only to that tool's own result items. Harness-level `opts.itemSchemas`
+        // stay global by design; sibling tools' schemas never reject this item.
         const outputItem = createToolResultItem({
             output: toolResult.output,
             callId: fc.callId,
-            roundItemSchemas,
+            roundItemSchemas: this.opts.itemSchemas.extend(toolForCall?.itemSchemas),
             tool: toolForCall,
             callItem: fc,
             args: parsedArgs,
@@ -605,13 +605,14 @@ export class AgentHarnessModelCaller {
         });
     }
     recordMalformedToolCall(params) {
-        const { fc, request, roundItemSchemas, allItems, conversationInput } = params;
+        const { fc, request, allItems, conversationInput } = params;
         const errorOutput = `Error: malformed JSON in tool arguments: ${fc.arguments}`;
         const toolForCall = request.tools?.find((tool) => tool.name === fc.name);
+        // Owner-scoped result validation (see executeFunctionCall).
         const outputItem = createToolResultItem({
             output: errorOutput,
             callId: fc.callId,
-            roundItemSchemas,
+            roundItemSchemas: this.opts.itemSchemas.extend(toolForCall?.itemSchemas),
             tool: toolForCall,
             callItem: fc,
             error: true,

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

@@ -5,6 +5,14 @@ export declare function buildItemSchemaRegistry({ base, layers, tools, }: {
     layers?: ReadonlyArray<MemoryLayer>;
     tools?: ReadonlyArray<Tool>;
 }): ItemSchemaRegistry;
+/**
+ * Build and validate a `function_call_output` item for a tool result.
+ *
+ * `roundItemSchemas` must be the OWNER-SCOPED registry for the called tool
+ * (harness base extended with only that tool's `itemSchemas`), so one tool's
+ * `toolResults` schemas never reject a sibling tool's result items. Tools
+ * without `itemSchemas` fall back to the base structural parse.
+ */
 export declare function createToolResultItem({ output, callId, roundItemSchemas, tool, callItem, args, result, error, }: {
     output: string;
     callId: string;

package/dist/harness/model-schema.js

@@ -24,6 +24,14 @@ export function buildItemSchemaRegistry({ base, layers, tools, }) {
         .extend(collectLayerItemSchemaExtensions(layers))
         .extend(collectToolItemSchemaExtensions(tools));
 }
+/**
+ * Build and validate a `function_call_output` item for a tool result.
+ *
+ * `roundItemSchemas` must be the OWNER-SCOPED registry for the called tool
+ * (harness base extended with only that tool's `itemSchemas`), so one tool's
+ * `toolResults` schemas never reject a sibling tool's result items. Tools
+ * without `itemSchemas` fall back to the base structural parse.
+ */
 export function createToolResultItem({ output, callId, roundItemSchemas, tool, callItem, args, result, error, }) {
     const baseItem = {
         id: crypto.randomUUID(),

package/dist/index.d.ts

@@ -55,7 +55,7 @@ export { execute } from './interpreter/execute.js';
 /** @public */
 /** @public */
 /** @public */
-export type { DurableTaskState, DurableTaskStateConfig, FactExtractor, FactSearcher, HistoryWindowConfig, ObservationalMemoryConfig, ObservationalState, PlanEnterSessionCallback, PlanExecutionEntry, PlanExitCallback, PlanMemoryConfig, PlanState, TemporalFact, TemporalMemoryConfig, TemporalSearchResult, WorkingMemoryConfig, WorkingMemoryState, } from '@noetic-tools/memory';
+export type { DurableTaskState, FactExtractor, FactSearcher, HistoryWindowConfig, ObservationalMemoryConfig, ObservationalState, PlanEnterSessionCallback, PlanExecutionEntry, PlanExitCallback, PlanMemoryConfig, PlanState, TemporalFact, TemporalMemoryConfig, TemporalSearchResult, WorkingMemoryConfig, WorkingMemoryState, } from '@noetic-tools/memory';
 /** @public */
 /** @public */
 /** @public */

package/dist/interpreter/execute-action.js

@@ -1,7 +1,7 @@
 /**
  * Action step handlers: run, llm, spawn, provide, tool.
  */
-import { createMessage, estimateTokens, extractAssistantText, frameworkCast, NoeticConfigError, NoeticErrorImpl, } from '@noetic-tools/types';
+import { createMessage, estimateTokens, extractAssistantText, frameworkCast, isNoeticError, NoeticConfigError, NoeticErrorImpl, } from '@noetic-tools/types';
 import { ZodError } from 'zod';
 import { allocateBudgets, assembleView, buildToolExecutionContext, ContextImpl, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, defaultItemSchemaRegistry, emitFrameworkEvent, getBroadcaster, resolveLayerTools, returnLayers, snapshotCwdState, spawnLayers, } from './action-deps.js';
 import { SteeringAction } from './action-types.js';
@@ -15,10 +15,23 @@ export async function executeRun(step, input, ctx) {
     const maxAttempts = retry?.maxAttempts ?? 1;
     let lastError = new Error('No attempts executed');
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        // Cancellation is not a retriable error (spec 09) — an abort that
+        // arrived between attempts must stop the loop before re-executing.
+        if (ctx.aborted) {
+            throw new NoeticErrorImpl({
+                kind: 'cancelled',
+                reason: ctx.abortReason ?? 'context aborted',
+            });
+        }
         try {
             return await step.execute(input, ctx);
         }
         catch (e) {
+            // Rethrow cancellation immediately — retrying it would re-run side
+            // effects after abort and bury the 'cancelled' kind under step_failed.
+            if (isNoeticError(e) && e.noeticError.kind === 'cancelled') {
+                throw e;
+            }
             lastError = e instanceof Error ? e : new Error(String(e));
             if (attempt < maxAttempts - 1 && retry) {
                 const delay = computeDelay(retry, attempt);
@@ -290,6 +303,11 @@ export async function executeLLM(step, input, ctx, layers) {
                 emit: step.emit,
             };
         const response = await baseCtx.harness.callModel(request);
+        // Track tokens/cost for EVERY model call, including responses steering
+        // subsequently rejects (Deny throw / Guide retry below) — the spend is
+        // real, and until.maxCost / HarnessResponse.usage must see it (spec 07:
+        // tokens accumulate across all LLM calls).
+        trackUsage(baseCtx, response);
         if (hasLayers) {
             const decision = await baseCtx.harness.afterModelCall(layers, response, baseCtx);
             if (decision.action === SteeringAction.Deny) {
@@ -320,7 +338,6 @@ export async function executeLLM(step, input, ctx, layers) {
         if (isMutableContext(baseCtx)) {
             baseCtx.lastStepMeta = meta;
         }
-        trackUsage(baseCtx, response);
         commitLayerUsage(baseCtx, computeLayerUsage({
             ctx: baseCtx,
             modelId: resolvedModel,

package/dist/interpreter/execute-control.js

@@ -135,9 +135,46 @@ function classifyResults(settled, paths) {
     };
 }
 async function executeAll(step, paths, _input, ctx, childContexts, executeStep, concurrency) {
-    const tasks = paths.map((path, i) => () => executeStep(path, _input, frameworkCast(childContexts[i])));
+    // Fail-fast (specs 03/09): the first genuine path failure aborts every
+    // sibling child context. Cancellation is cooperative — in-flight siblings
+    // are still awaited (they stop at their next step boundary / blocked
+    // channel op) so fork_partial's succeeded/failed stay accurate; paths
+    // still queued behind the concurrency limit are skipped outright. Skipped
+    // and aborted paths appear in `failed` with kind 'cancelled'.
+    let firstFailureSeen = false;
+    const tasks = paths.map((path, i) => async () => {
+        if (firstFailureSeen) {
+            throw new NoeticErrorImpl({
+                kind: 'cancelled',
+                reason: `fork '${step.id}' sibling failed`,
+            });
+        }
+        try {
+            return await executeStep(path, _input, frameworkCast(childContexts[i]));
+        }
+        catch (e) {
+            const isCancellation = isNoeticError(e) && e.noeticError.kind === 'cancelled';
+            if (!isCancellation && !firstFailureSeen) {
+                firstFailureSeen = true;
+                for (let j = 0; j < childContexts.length; j++) {
+                    if (j !== i) {
+                        childContexts[j].abort(`fork '${step.id}' sibling failed`);
+                    }
+                }
+            }
+            throw e;
+        }
+    });
     const settled = await runWithConcurrency(tasks, concurrency);
     const { succeeded, failed } = classifyResults(settled, paths);
+    // If the PARENT context was aborted mid-fork, the whole fork is cancelled —
+    // surface 'cancelled', not a partial-failure shape (spec 09, item 3).
+    if (ctx.aborted) {
+        throw new NoeticErrorImpl({
+            kind: 'cancelled',
+            reason: ctx.abortReason ?? 'context aborted',
+        });
+    }
     if (failed.length > 0) {
         throw new NoeticErrorImpl({
             kind: 'fork_partial',
@@ -208,9 +245,17 @@ async function executeRace(step, paths, input, ctx, childContexts, executeStep,
         }
     });
 }
-async function executeSettle(step, paths, input, _ctx, childContexts, executeStep, concurrency) {
+async function executeSettle(step, paths, input, ctx, childContexts, executeStep, concurrency) {
     const tasks = paths.map((path, i) => () => executeStep(path, input, frameworkCast(childContexts[i])));
     const settled = await runWithConcurrency(tasks, concurrency);
+    // Parent aborted mid-fork: the fork is cancelled, merge never runs
+    // (spec 09, Cancellation item 3 — same rule as mode 'all').
+    if (ctx.aborted) {
+        throw new NoeticErrorImpl({
+            kind: 'cancelled',
+            reason: ctx.abortReason ?? 'context aborted',
+        });
+    }
     const results = settled.map((result, i) => {
         if (result.status === 'fulfilled') {
             return {
@@ -225,7 +270,7 @@ async function executeSettle(step, paths, input, _ctx, childContexts, executeSte
             error: toNoeticError(result.reason, paths[i].id),
         };
     });
-    return step.merge(results, _ctx);
+    return step.merge(results, ctx);
 }
 function hasTextField(value) {
     return typeof value === 'object' && value !== null && 'text' in value;
@@ -242,7 +287,11 @@ async function recvInboxWithTimeout(ctx, step) {
             timeout: step.parkTimeout,
         });
     }
-    catch {
+    catch (e) {
+        // Cancellation must terminate the loop, not read as "no message".
+        if (isNoeticError(e) && e.noeticError.kind === 'cancelled') {
+            throw e;
+        }
         // Expected: channel_timeout error when parkTimeout expires with no message.
         return null;
     }
@@ -307,6 +356,12 @@ export async function executeLoop(step, input, ctx, executeStep) {
             if (!step.onError || !isNoeticError(e)) {
                 throw e;
             }
+            // Cancellation is not a retriable error (spec 09): it must terminate
+            // the loop promptly rather than be consumed by 'retry'/'skip'. Same
+            // guard as executeEvery's 'continue' policy below.
+            if (e.noeticError.kind === 'cancelled') {
+                throw e;
+            }
             const action = step.onError(e.noeticError, ctx);
             if (action === 'retry') {
                 continue;

package/dist/runtime/channel-store.d.ts

@@ -1,4 +1,14 @@
 import type { Channel, ChannelHandle, ExternalChannel } from '@noetic-tools/types';
+/** Options accepted by internal (back-pressured) `send`. */
+export interface ChannelSendOpts {
+    /**
+     * How long a sender may stay parked on a full queue before rejecting with
+     * `channel_timeout`. Default 30s; `0` disables the timeout.
+     */
+    timeout?: number;
+    /** Abort signal — rejects a parked sender with `cancelled`. */
+    signal?: AbortSignal;
+}
 export declare class ChannelStore {
     private channels;
     private closedExecutions;
@@ -9,10 +19,40 @@ export declare class ChannelStore {
      * an `unsubscribe` so the caller can detach if it cancels first.
      */
     subscribeWake<T>(channel: Channel<T>, callback: () => void): () => void;
-    send<T>(channel: Channel<T>, value: T): void;
-    recv<T>(channel: Channel<T>, timeout?: number): Promise<T>;
+    /**
+     * Internal-sender write with back-pressure (spec 06). Delivery is
+     * synchronous when possible; the returned promise only parks when a queue
+     * channel is at capacity:
+     *
+     * - **value**: store last-write-wins value, drain ALL parked recv waiters,
+     *   resolve immediately.
+     * - **queue**: hand off to a parked recv waiter or push below capacity —
+     *   resolve immediately. At capacity, park the sender FIFO until a consumer
+     *   dequeues an item; reject `channel_timeout` after `opts.timeout`
+     *   (default 30s) or `cancelled` when `opts.signal` aborts.
+     * - **topic**: deliver to current subscribers, resolve immediately.
+     *
+     * External callers use `ChannelHandle.send` (sync, drop-oldest) instead.
+     */
+    send<T>(channel: Channel<T>, value: T, opts?: ChannelSendOpts): Promise<void>;
+    /** Park an internal sender on a full queue until a slot frees (FIFO). */
+    private parkSender;
+    /**
+     * A dequeue freed a queue slot — shift the oldest parked sender's value
+     * into it (FIFO) and resolve that sender's promise.
+     */
+    private promotePendingSender;
+    /** Fire-and-reset the one-shot wake subscribers for a channel state. */
+    private fireWakes;
+    recv<T>(channel: Channel<T>, timeout?: number, signal?: AbortSignal): Promise<T>;
     tryRecv<T>(channel: Channel<T>): T | null;
     private waitWithTimeout;
+    /**
+     * External-sender write: synchronous, never back-pressured (spec 06,
+     * External Sender Back-Pressure). At capacity the OLDEST queued item is
+     * dropped (with a warning) so external callers never block.
+     */
+    private sendExternal;
     getHandle<T>(channel: ExternalChannel<T>, executionId: string): ChannelHandle<T>;
     closeExecution(executionId: string): void;
 }