@noetic-tools/core 5.4.1 → 5.5.0

package/dist/adapters/openrouter.js

@@ -308,7 +308,7 @@ export async function executeToolCall(params) {
         };
     }
     if (params.layers && params.layers.length > 0) {
-        const decision = await params.harness.beforeToolCall(params.layers, params.toolName, params.args, params.context);
+        const decision = await params.harness.beforeToolCall(params.layers, params.toolName, params.args, params.context, params.callId);
         if (decision.action === SteeringAction.Deny) {
             return {
                 output: `Tool call denied: ${decision.guidance ?? 'steering rule violation'}`,

package/dist/builders/tool-builder.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionCallItem, FunctionCallOutputItem, InferSchemaOutput, InputSchemaConfig, Item, ItemSchemaExtensions, StandardSchemaV1, Tool, ToolContextDeclaration, ToolExecutionContext, ToolResultExtensionItem, ToolUiDeclaration } from '@noetic-tools/types';
+import type { FunctionCallItem, FunctionCallOutputItem, InferSchemaOutput, InputSchemaConfig, Item, ItemSchemaExtensions, StandardSchemaV1, Tool, ToolAcpDeclaration, ToolContextDeclaration, ToolExecutionContext, ToolResultExtensionItem, ToolUiDeclaration } from '@noetic-tools/types';
 type ToolConfig<I extends StandardSchemaV1, O extends StandardSchemaV1> = {
     name: string;
     description: string;
@@ -19,6 +19,8 @@ type ToolConfig<I extends StandardSchemaV1, O extends StandardSchemaV1> = {
     context?: ToolContextDeclaration;
     /** Optional UI declaration — the runtime emits the rendered fragments at call/progress/result points. */
     ui?: ToolUiDeclaration<I, O>;
+    /** Optional ACP presentation — how the call renders in an ACP client when the harness is served as an agent. */
+    acp?: ToolAcpDeclaration<I>;
 } & InputSchemaConfig<I>;
 type GeneratorToolConfig<I extends StandardSchemaV1, E extends StandardSchemaV1, O extends StandardSchemaV1> = {
     name: string;
@@ -41,6 +43,8 @@ type GeneratorToolConfig<I extends StandardSchemaV1, E extends StandardSchemaV1,
     context?: ToolContextDeclaration;
     /** Optional UI declaration — the runtime emits the rendered fragments at call/progress/result points. */
     ui?: ToolUiDeclaration<I, O, InferSchemaOutput<E>>;
+    /** Optional ACP presentation — how the call renders in an ACP client when the harness is served as an agent. */
+    acp?: ToolAcpDeclaration<I>;
 } & InputSchemaConfig<I>;
 /**
  * Creates a typed Tool with Standard Schema inference for input and output.

package/dist/builders/tool-builder.js

@@ -39,6 +39,7 @@ export function tool(config) {
         needsApproval: config.needsApproval,
         context: config.context,
         ui: config.ui,
+        acp: config.acp,
     };
 }
 /**
@@ -61,6 +62,7 @@ export function toolWithGenerator(config) {
         needsApproval: config.needsApproval,
         context: config.context,
         ui: config.ui,
+        acp: config.acp,
     };
 }
 //#endregion

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

@@ -271,6 +271,8 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
         threadId?: string;
         resourceId?: string;
         contextLayers?: ContextLayer[];
+        /** Additional layers appended AFTER the effective set — never replaces it. */
+        extraContextLayers?: ContextLayer[];
         /**
          * Initial cwd for the new context. When set, takes precedence over both
          * the parent snapshot and the harness root cwd — used by worktree
@@ -393,7 +395,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     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): Promise<SteeringDecision>;
+    beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context, callId?: string): Promise<SteeringDecision>;
     afterModelCall(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
     projectHistory(layers: ContextLayer[], items: ReadonlyArray<Item>, ctx: Context): Promise<ReadonlyArray<Item>>;
     runAppendPipeline(layers: ContextLayer[], items: Item[], ctx: Context): Promise<{

package/dist/harness/agent-harness.js

@@ -439,6 +439,7 @@ export class AgentHarness {
                         resourceId: perTurnOptions.resourceId,
                         state: perTurnOptions.state,
                         contextLayers: perTurnOptions.contextLayers,
+                        extraContextLayers: perTurnOptions.extraContextLayers,
                         _broadcaster: session.runner.broadcaster,
                     });
                     const ext = frameworkCast(ctx);
@@ -596,8 +597,14 @@ export class AgentHarness {
         const resolved = opts ?? {};
         // `ContextImpl` takes the layers as `layers`, so the option spelling is
         // dropped from `rest` rather than spread through under the wrong name.
-        const { contextLayers, cwdInit, ...rest } = resolved;
-        const effectiveLayers = contextLayers ?? this._contextLayers;
+        const { contextLayers, extraContextLayers, cwdInit, ...rest } = resolved;
+        const baseLayers = contextLayers ?? this._contextLayers;
+        const effectiveLayers = extraContextLayers && extraContextLayers.length > 0
+            ? [
+                ...(baseLayers ?? []),
+                ...extraContextLayers,
+            ]
+            : baseLayers;
         const itemSchemas = buildItemSchemaRegistry({
             base: this.itemSchemas,
             layers: effectiveLayers,
@@ -948,7 +955,7 @@ export class AgentHarness {
     setLayerState(executionId, layerId, state) {
         this.layerStateStore.set(executionId, layerId, state);
     }
-    async beforeToolCall(layers, toolName, toolArgs, ctx) {
+    async beforeToolCall(layers, toolName, toolArgs, ctx, callId) {
         const hasHook = layers.some((l) => l.hooks.beforeToolCall);
         if (!hasHook) {
             return {
@@ -959,6 +966,7 @@ export class AgentHarness {
             layers,
             toolName,
             toolArgs,
+            callId,
             ctx: this.toExecCtx(ctx),
             store: this.layerStateStore,
         });

package/dist/harness/model-call.js

@@ -749,7 +749,8 @@ export class AgentHarnessModelCaller {
         params.emitIfAllowed('tool_call_completed', {
             name: fc.name,
             callId: fc.callId,
-            error: false,
+            error: toolResult.error === true,
+            output: toolResult.output,
         });
     }
     recordMalformedToolCall(params) {
@@ -776,6 +777,7 @@ export class AgentHarnessModelCaller {
             name: fc.name,
             callId: fc.callId,
             error: true,
+            output: errorOutput,
         });
     }
     handleToolRoundLimit(params) {

package/dist/interpreter/execute-acp-agent.js

@@ -132,7 +132,7 @@ function buildSteerer(ctx, layers) {
         return undefined;
     }
     return async (request) => {
-        const decision = await ctx.harness.beforeToolCall(layers, request.toolCall.title ?? request.toolCall.toolCallId, request.toolCall.rawInput, ctx);
+        const decision = await ctx.harness.beforeToolCall(layers, request.toolCall.title ?? request.toolCall.toolCallId, request.toolCall.rawInput, ctx, request.toolCall.toolCallId);
         if (decision.action === SteeringAction.Allow) {
             return undefined;
         }

package/dist/interpreter/execute-action.js

@@ -386,26 +386,11 @@ function buildModelRequest(params) {
     const { step, ctx, layers } = params;
     const _serverTools = params.serverToolSpecs.length > 0 ? params.serverToolSpecs : undefined;
     const signal = isContextImpl(ctx) ? ctx.abortSignal : undefined;
-    if (params.resolvedTools) {
-        return {
-            model: params.resolvedModel,
-            items: params.assembledItems,
-            instructions: params.resolvedInstructions,
-            tools: params.resolvedTools,
-            params: step.params,
-            outputSchema: params.outputSchema,
-            outputJsonSchema: params.step.outputJsonSchema,
-            emit: step.emit,
-            _serverTools,
-            ctx,
-            layers,
-            allowedToolNames: params.allowedToolNames,
-            nodeId: step.id,
-            parentSpan: ctx.span,
-            signal,
-        };
-    }
-    return {
+    // One construction for both shapes: the tool fields vary, but `ctx` (which
+    // carries the broadcaster — without it a tool-less call streams NOTHING to
+    // getFullStream/getTextStream) and `layers` must be attached either way.
+    // The two hand-maintained branches this replaces had drifted exactly there.
+    const base = {
         model: params.resolvedModel,
         items: params.assembledItems,
         instructions: params.resolvedInstructions,
@@ -414,10 +399,20 @@ function buildModelRequest(params) {
         outputJsonSchema: params.step.outputJsonSchema,
         emit: step.emit,
         _serverTools,
+        ctx,
+        layers,
         nodeId: step.id,
         parentSpan: ctx.span,
         signal,
     };
+    if (params.resolvedTools) {
+        return {
+            ...base,
+            tools: params.resolvedTools,
+            allowedToolNames: params.allowedToolNames,
+        };
+    }
+    return base;
 }
 /**
  * Records a finished model response on the context: appends response items to
@@ -881,9 +876,37 @@ export async function executeInvokeTool(step, input, ctx, harness, layers) {
         });
     }
     const parsedArgs = parseResult.value;
+    // The started event precedes the gate so a parked call (e.g. one awaiting an
+    // external permission decision) is visible as pending rather than invisible
+    // until approved — the same ordering the model-driven path guarantees.
+    const broadcaster = getBroadcaster(baseCtx);
+    const agentName = baseCtx.harness.config.name;
+    emitFrameworkEvent({
+        broadcaster,
+        agentName,
+        eventType: 'tool_call_started',
+        data: {
+            name: step.tool.name,
+            callId: step.id,
+        },
+    });
+    const emitCompleted = (error, output) => {
+        emitFrameworkEvent({
+            broadcaster,
+            agentName,
+            eventType: 'tool_call_completed',
+            data: {
+                name: step.tool.name,
+                callId: step.id,
+                error,
+                output,
+            },
+        });
+    };
     if (layers && layers.length > 0) {
-        const decision = await harness.beforeToolCall(layers, step.tool.name, parsedArgs, baseCtx);
+        const decision = await harness.beforeToolCall(layers, step.tool.name, parsedArgs, baseCtx, step.id);
         if (decision.action !== SteeringAction.Allow) {
+            emitCompleted(true, `Tool call denied: ${decision.guidance ?? 'steering rule violation'}`);
             throw new NoeticErrorImpl({
                 kind: 'steering_denied',
                 guidance: decision.guidance,
@@ -917,6 +940,7 @@ export async function executeInvokeTool(step, input, ctx, harness, layers) {
             args: parsedArgs,
             output: result,
         });
+        emitCompleted(false, typeof result === 'string' ? result : JSON.stringify(result));
         return frameworkCast(result);
     }
     catch (e) {
@@ -928,6 +952,7 @@ export async function executeInvokeTool(step, input, ctx, harness, layers) {
             args: parsedArgs,
             error: e,
         });
+        emitCompleted(true, e instanceof Error ? e.message : String(e));
         if (e instanceof NoeticErrorImpl) {
             throw e;
         }

package/dist/runtime/session-runner.js

@@ -1,3 +1,4 @@
+import { isNoeticError } from '@noetic-tools/types';
 import { emitFrameworkEvent } from './broadcaster-utils.js';
 import { EventBroadcaster } from './event-broadcaster.js';
 import { MessageQueue } from './message-queue.js';
@@ -240,6 +241,9 @@ export class SessionRunner {
                 data: {
                     turnId,
                     reason: error.message,
+                    // The typed kind ('cancelled', 'model_refused', …) so consumers can
+                    // classify the abort without parsing the human-readable message.
+                    errorKind: isNoeticError(error) ? error.noeticError.kind : undefined,
                 },
             });
             this.rejectWaiters(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/core",
-  "version": "5.4.1",
+  "version": "5.5.0",
   "type": "module",
   "description": "Step primitives, interpreter, runtime, and context layer contract for Noetic agents.",
   "license": "Apache-2.0",
@@ -68,8 +68,8 @@
     }
   },
   "dependencies": {
-    "@noetic-tools/context": "^1.2.2",
-    "@noetic-tools/types": "^3.2.2",
+    "@noetic-tools/context": "^1.3.0",
+    "@noetic-tools/types": "^3.3.0",
     "@openrouter/agent": "^0.6.0",
     "zod": "^4.0.0"
   },