@noetic-tools/core 5.4.0 → 5.4.1

package/dist/harness/agent-harness.js

@@ -1,6 +1,7 @@
 import { frameworkCast, ItemSchemaRegistry, NoeticConfigError } from '@noetic-tools/types';
 import { SpanImpl } from '../observability/span-impl.js';
 import { NoopExporter } from '../observability/trace-exporter.js';
+import { AcpSessionStore } from '../runtime/acp-session-store.js';
 import { createInMemoryFsAdapter, createInMemoryShellAdapter, createInMemorySubprocessAdapter, OpenRouter, } from './deps/adapters.js';
 import { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createContextCacheStore, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from './deps/context.js';
 import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, prepareBandedView, } from './deps/interpreter.js';
@@ -192,12 +193,53 @@ export class AgentHarness {
     defaultDeliveryMode;
     sessions = new Map();
     /**
-     * @internal Cross-step harness sessions keyed by `step.session.reuse`, kept
-     * alive for the life of this harness so reused coding-agent sessions span
-     * multiple steps. Reached by the interpreter's harness handler via
-     * `frameworkCast`; do not access from outside core.
+     * @internal Live ACP connections. Reached by the interpreter via
+     * `frameworkCast`; use {@link listAcpSessions}, {@link getAcpSession},
+     * {@link cancelAcpSession}, and {@link closeAcpSessions} from outside core.
      */
-    subHarnessSessions = new Map();
+    acpSessions = new AcpSessionStore();
+    /**
+     * Snapshot of every live ACP sub-agent, for a UI that wants to show what is
+     * running and let a user act on it. Read-only: a session's turns are driven
+     * by steps, so nothing here can start work behind the runtime's back.
+     * @public
+     */
+    listAcpSessions() {
+        return this.acpSessions.list();
+    }
+    /**
+     * The live connection + session behind a handle from {@link listAcpSessions}
+     * (or a step's `session.reuse` key), or `undefined` when nothing matches.
+     * @public
+     */
+    getAcpSession(key) {
+        return this.acpSessions.get(key);
+    }
+    /**
+     * Interrupt whatever the sub-agent under `key` is doing, via `session/cancel`.
+     * The connection stays open and the turn still returns — with the `cancelled`
+     * stop reason, which the running step surfaces as a `cancelled` error.
+     * Returns false when nothing matches the key.
+     * @public
+     */
+    async cancelAcpSession(key) {
+        const entry = this.acpSessions.get(key);
+        if (!entry) {
+            return false;
+        }
+        await entry.session.cancel();
+        return true;
+    }
+    /**
+     * Close every ACP connection this harness still holds, whatever its
+     * keep-alive scope. A connection owns a live agent — usually a child process
+     * whose stdio keeps the event loop alive — so a `keepAlive: 'harness'`
+     * session must be closed by its owner or the host will not exit. Idempotent.
+     * @public
+     */
+    async closeAcpSessions() {
+        await this.acpSessions.closeAll();
+    }
     layerStateStore;
     /** Per-harness memoization cache for `recallMode: 'eventual'` layers. */
     recallCache;
@@ -520,6 +562,7 @@ export class AgentHarness {
             else {
                 this.rootRunDepth.delete(ctx.id);
                 this.channelStore.closeExecution(ctx.id);
+                await this.acpSessions.closeOwnedBy(ctx.id);
             }
         }
     }
@@ -848,7 +891,7 @@ export class AgentHarness {
      *
      * Aborting a context rejects everything blocked on it (channel `recv`
      * waiters, parked senders) with `{ kind: 'cancelled' }`, stops its in-flight
-     * model call and sub-harness turn, and makes the next step boundary throw
+     * model call and ACP agent turn, and makes the next step boundary throw
      * `cancelled`.
      *
      * Cancellation is cooperative: a layer hook already in flight is allowed to

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

@@ -1,4 +1,4 @@
 export type { ContextCacheConfig, ContextCacheStore, ContextData, ContextLayer, ExecutionContext, ProjectionPolicy, StorageAdapter, } from '@noetic-tools/context';
-export type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaConfig, ItemSchemaExtensions, LLMResponse, LlmProviderConfig, RecallLayerOutput, SessionScope, SessionUsage, ShellAdapter, Span, SteeringDecision, Step, StreamEvent, StreamingItem, SubHarnessSession, SubprocessAdapter, Tool, TraceExporter, } from '@noetic-tools/types';
+export type { AcpKeepAlive, AcpLiveSession, AcpSessionInfo, AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaConfig, ItemSchemaExtensions, LLMResponse, LlmProviderConfig, RecallLayerOutput, SessionScope, SessionUsage, ShellAdapter, Span, SteeringDecision, Step, StreamEvent, StreamingItem, SubprocessAdapter, Tool, TraceExporter, } from '@noetic-tools/types';
 export { SteeringAction } from '@noetic-tools/types';
 export type { ZodType } from 'zod';

package/dist/index.d.ts

@@ -7,6 +7,10 @@ export { createInMemorySubprocessAdapter } from './adapters/in-memory-subprocess
 /** @public */
 export { createOpenRouterEmbed } from './adapters/openrouter.js';
 /** @public */
+export type { AcpAgentToolOptions } from './builders/acp-agent-tool.js';
+/** @public */
+export { acpAgentTool } from './builders/acp-agent-tool.js';
+/** @public */
 export { channel } from './builders/channel-builder.js';
 /** @public */
 export { context } from './builders/context-builder.js';
@@ -100,7 +104,7 @@ export { getRegistry, lookupStep, registerStep } from './runtime/step-registry.j
 /** @public */
 export { defaultItemSchemaRegistry, ItemSchema, ItemSchemaRegistry } from '@noetic-tools/types';
 /** @public */
-export type { CallModelWorkflowNode, ConditionalRoute, ConditionalWorkflowNode, InParallelWorkflowNode, InvokeToolWorkflowNode, LoopWorkflowNode, MergeStrategy, ScheduleWorkflowNode, SequenceWorkflowNode, SpawnWorkflowNode, SubflowWorkflowNode, SubHarnessWorkflowNode, UntilPredicate, WithContextWorkflowNode, WorkflowDocument, WorkflowNode, } from './schemas/workflow.js';
+export type { AcpAgentWorkflowNode, CallModelWorkflowNode, ConditionalRoute, ConditionalWorkflowNode, InParallelWorkflowNode, InvokeToolWorkflowNode, LoopWorkflowNode, MergeStrategy, ScheduleWorkflowNode, SequenceWorkflowNode, SpawnWorkflowNode, SubflowWorkflowNode, UntilPredicate, WithContextWorkflowNode, WorkflowDocument, WorkflowNode, } from './schemas/workflow.js';
 /** @public */
 export { MergeStrategySchema, UntilPredicateSchema, validateWorkflow, WorkflowDocumentSchema, WorkflowNodeSchema, walkWorkflow, workflowDepth, } from './schemas/workflow.js';
 /** @public */
@@ -147,11 +151,11 @@ export type { AfterModelCallParams, AfterModelCallResult, BeforeToolCallParams,
 /** @public */
 export { LedgerEntryKind, SteeringAction } from '@noetic-tools/types';
 /** @public */
-export type { ExecuteStepFn, SettleResult, Snapshot, Step, StepCallModel, StepConditional, StepInParallel, StepInParallelAll, StepInParallelRace, StepInParallelSettle, StepInvokeTool, StepLoop, StepRunCode, StepSpawn, StepSubHarness, StepWithContext, Until, Verdict, } from '@noetic-tools/types';
+export type { ExecuteStepFn, SettleResult, Snapshot, Step, StepAcpAgent, StepCallModel, StepConditional, StepInParallel, StepInParallelAll, StepInParallelRace, StepInParallelSettle, StepInvokeTool, StepLoop, StepRunCode, StepSpawn, StepWithContext, Until, Verdict, } from '@noetic-tools/types';
 /** @public */
-export type { SubHarness, SubHarnessBuiltinTool, SubHarnessContinueState, SubHarnessContinueTurnOptions, SubHarnessFinishReason, SubHarnessPromptTurnOptions, SubHarnessResumeState, SubHarnessRunContext, SubHarnessSession, SubHarnessSessionPolicy, SubHarnessSettings, SubHarnessStartOptions, SubHarnessStreamPart, SubHarnessTurnResult, } from '@noetic-tools/types';
+export type { AcpAgent, AcpAgentCapabilities, AcpAgentConnection, AcpAuthMethod, AcpAvailableCommand, AcpBoundPermissionHandler, AcpClientCapabilityConfig, AcpClientHost, AcpConnectOptions, AcpContentBlock, AcpKeepAlive, AcpLiveSession, AcpLoadSessionOptions, AcpMcpServer, AcpNewSessionOptions, AcpPermissionHandler, AcpPermissionOption, AcpPermissionOutcome, AcpPermissionPolicy, AcpPermissionRequestInfo, AcpPermissionRule, AcpPermissionSteerer, AcpPlanEntry, AcpPromptCapabilities, AcpPromptOptions, AcpRequestPermissionRequest, AcpSession, AcpSessionDisposer, AcpSessionInfo, AcpSessionMode, AcpSessionModeState, AcpSessionNotification, AcpSessionPolicy, AcpStopReason, AcpToolCallContent, AcpToolCallStatus, AcpToolKind, AcpTransport, AcpTransportFactory, AcpTransportOptions, AcpTurnResult, } from '@noetic-tools/types';
 /** @public */
-export { SUB_HARNESS_KINDS, SubHarnessKind, SubHarnessStreamPartSchema } from '@noetic-tools/types';
+export { ACP_AGENT_STEP_KIND, AcpCapabilityError, AcpConnectError, AcpPermissionDecision, isAcpCapabilityError, isAcpConnectError, } from '@noetic-tools/types';
 /** @public */
 export type { FsAdapter, FsStats } from '@noetic-tools/types';
 /** @public */

package/dist/index.js

@@ -7,8 +7,8 @@ export { createInMemoryShellAdapter } from './adapters/in-memory-shell-adapter.j
 export { createInMemorySubprocessAdapter } from './adapters/in-memory-subprocess-adapter.js';
 /** @public */
 export { createOpenRouterEmbed } from './adapters/openrouter.js';
-//#endregion
-//#region Builders
+/** @public */
+export { acpAgentTool } from './builders/acp-agent-tool.js';
 /** @public */
 export { channel } from './builders/channel-builder.js';
 /** @public */
@@ -100,7 +100,7 @@ export { Slot } from '@noetic-tools/context';
 /** @public */
 export { LedgerEntryKind, SteeringAction } from '@noetic-tools/types';
 /** @public */
-export { SUB_HARNESS_KINDS, SubHarnessKind, SubHarnessStreamPartSchema } from '@noetic-tools/types';
+export { ACP_AGENT_STEP_KIND, AcpCapabilityError, AcpConnectError, AcpPermissionDecision, isAcpCapabilityError, isAcpConnectError, } from '@noetic-tools/types';
 /** @public */
 export { TIMEOUT_ERROR_PREFIX } from '@noetic-tools/types';
 /** @public Reusable error-serialiser used by custom SubprocessAdapter implementations. */

package/dist/interpreter/acp-events.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Maps an ACP turn's `session/update` notifications onto the harness's
+ * observable event surface.
+ *
+ * Every one of the protocol's eight update variants is translated into the same
+ * `source: 'sdk'` broadcaster events the model-call path emits, so a coding
+ * agent's text, reasoning, and tool calls flow through `getTextStream()` /
+ * `getReasoningStream()` / `getItemStream()` / `getFullStream()` exactly like an
+ * LLM step's output. Each notification is *also* re-emitted raw as an
+ * `acp_event` framework event for consumers that want the protocol payload.
+ *
+ * `finalize()` guarantees a turn always emits its output: if an agent returns a
+ * stop reason without streaming any text or tool calls, the result's content is
+ * synthesized into events.
+ */
+import type { AcpClientActivity, AcpSessionNotification, AcpTurnResult, Context, ContextData, StepAcpAgent } from '@noetic-tools/types';
+export declare class AcpEventBridge {
+    private readonly broadcaster?;
+    private readonly agentName;
+    private readonly stepId;
+    private readonly agentId;
+    private readonly emitOption;
+    private started;
+    private completed;
+    private nextOutputIndex;
+    private messageOutputIndex;
+    private sawText;
+    /** Tool call ids already announced, so a `tool_call_update` never re-opens one. */
+    private readonly announcedToolCalls;
+    constructor(step: Pick<StepAcpAgent, 'id' | 'emit'>, agentId: string, ctx: Context<ContextData>);
+    /**
+     * Open the turn on the event surface. Emits `response.created` so every turn
+     * brackets with a lifecycle marker — even an agent that streams nothing.
+     */
+    begin(): void;
+    /**
+     * Record one client-side operation the agent performed. Unlike a `tool_call`
+     * update — which is the agent's own account of what it did — this is what it
+     * actually asked us to do, refusals included.
+     */
+    forwardActivity(activity: AcpClientActivity): void;
+    /** Forward one notification: a structured framework event + the mapped sdk events. */
+    forward(notification: AcpSessionNotification): void;
+    /**
+     * Ensure the turn's output reached the event surface. For an agent that
+     * returns a result without streaming, synthesize events from the result.
+     */
+    finalize(result: AcpTurnResult): void;
+    /**
+     * Close a turn that failed. The bracket a consumer waits on must be honoured
+     * even when the turn dies mid-stream, so an open message is closed and the
+     * response completes with an error rather than the stream simply stopping.
+     */
+    abort(cause: unknown): void;
+    /**
+     * Emit one framework event under this step's envelope. The `sdk` sibling
+     * below does the same job for the model-stream surface; both gate on
+     * `emitOption` so `emit: false` silences every surface at once.
+     */
+    private framework;
+    private sdk;
+    private start;
+    private openMessage;
+    private closeMessage;
+    private emitToolCall;
+    private translate;
+}

package/dist/interpreter/acp-events.js

@@ -0,0 +1,256 @@
+/**
+ * Maps an ACP turn's `session/update` notifications onto the harness's
+ * observable event surface.
+ *
+ * Every one of the protocol's eight update variants is translated into the same
+ * `source: 'sdk'` broadcaster events the model-call path emits, so a coding
+ * agent's text, reasoning, and tool calls flow through `getTextStream()` /
+ * `getReasoningStream()` / `getItemStream()` / `getFullStream()` exactly like an
+ * LLM step's output. Each notification is *also* re-emitted raw as an
+ * `acp_event` framework event for consumers that want the protocol payload.
+ *
+ * `finalize()` guarantees a turn always emits its output: if an agent returns a
+ * stop reason without streaming any text or tool calls, the result's content is
+ * synthesized into events.
+ */
+import { emitFrameworkEvent, getBroadcaster, shouldEmit } from '../runtime/broadcaster-utils.js';
+import { isFunctionCall } from './typeguards.js';
+/** Flatten an ACP content block for the text event surface. */
+function blockText(block) {
+    if (block.type === 'text') {
+        return block.text;
+    }
+    if (block.type === 'resource_link') {
+        return `[resource: ${block.uri}]`;
+    }
+    if (block.type === 'resource') {
+        return 'text' in block.resource ? block.resource.text : `[resource: ${block.resource.uri}]`;
+    }
+    return `[${block.type}: ${block.mimeType}]`;
+}
+export class AcpEventBridge {
+    broadcaster;
+    agentName;
+    stepId;
+    agentId;
+    emitOption;
+    started = false;
+    completed = false;
+    nextOutputIndex = 0;
+    messageOutputIndex = null;
+    sawText = false;
+    /** Tool call ids already announced, so a `tool_call_update` never re-opens one. */
+    announcedToolCalls = new Set();
+    constructor(step, agentId, ctx) {
+        this.broadcaster = getBroadcaster(ctx);
+        this.agentName = ctx.harness.config.name;
+        this.stepId = step.id;
+        this.agentId = agentId;
+        this.emitOption = step.emit;
+    }
+    /**
+     * Open the turn on the event surface. Emits `response.created` so every turn
+     * brackets with a lifecycle marker — even an agent that streams nothing.
+     */
+    begin() {
+        this.start();
+    }
+    /**
+     * Record one client-side operation the agent performed. Unlike a `tool_call`
+     * update — which is the agent's own account of what it did — this is what it
+     * actually asked us to do, refusals included.
+     */
+    forwardActivity(activity) {
+        this.framework('acp_client_activity', {
+            ...activity,
+        });
+    }
+    /** Forward one notification: a structured framework event + the mapped sdk events. */
+    forward(notification) {
+        if (!this.broadcaster) {
+            return;
+        }
+        this.framework('acp_event', {
+            sessionId: notification.sessionId,
+            update: notification.update,
+        });
+        this.translate(notification.update);
+    }
+    /**
+     * Ensure the turn's output reached the event surface. For an agent that
+     * returns a result without streaming, synthesize events from the result.
+     */
+    finalize(result) {
+        if (!this.broadcaster) {
+            return;
+        }
+        if (!this.sawText && result.text.length > 0) {
+            this.openMessage();
+            this.sdk('response.output_text.delta', {
+                delta: result.text,
+            }, this.messageOutputIndex ?? 0);
+            this.sawText = true;
+        }
+        // Close the message before synthesizing tool calls, so output items finish
+        // in index order. Emitting them first left item 0 closing after items 1..n,
+        // which reads as interleaved output to a consumer tracking `outputIndex`.
+        this.closeMessage();
+        for (const item of result.items) {
+            if (isFunctionCall(item) && !this.announcedToolCalls.has(item.callId)) {
+                this.emitToolCall(item.callId, item.name, item.arguments);
+            }
+        }
+        if (!this.completed) {
+            this.start();
+            this.sdk('response.completed', {
+                stopReason: result.stopReason,
+            });
+            this.completed = true;
+        }
+    }
+    /**
+     * Close a turn that failed. The bracket a consumer waits on must be honoured
+     * even when the turn dies mid-stream, so an open message is closed and the
+     * response completes with an error rather than the stream simply stopping.
+     */
+    abort(cause) {
+        if (!this.broadcaster || this.completed) {
+            return;
+        }
+        this.closeMessage();
+        this.start();
+        this.sdk('response.completed', {
+            stopReason: 'error',
+            error: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.completed = true;
+    }
+    //#region internals
+    /**
+     * Emit one framework event under this step's envelope. The `sdk` sibling
+     * below does the same job for the model-stream surface; both gate on
+     * `emitOption` so `emit: false` silences every surface at once.
+     */
+    framework(eventType, payload) {
+        if (!this.broadcaster) {
+            return;
+        }
+        const data = {
+            stepId: this.stepId,
+            agentId: this.agentId,
+            ...payload,
+        };
+        if (!shouldEmit(this.emitOption, eventType, data)) {
+            return;
+        }
+        emitFrameworkEvent({
+            broadcaster: this.broadcaster,
+            agentName: this.agentName,
+            eventType,
+            data,
+        });
+    }
+    sdk(type, data, outputIndex) {
+        if (!this.broadcaster) {
+            return;
+        }
+        if (!shouldEmit(this.emitOption, type, data)) {
+            return;
+        }
+        this.broadcaster.emit({
+            source: 'sdk',
+            type,
+            data,
+            outputIndex,
+        });
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.sdk('response.created', {});
+    }
+    openMessage() {
+        if (this.messageOutputIndex !== null) {
+            return;
+        }
+        this.start();
+        const id = `acp-msg-${crypto.randomUUID()}`;
+        this.messageOutputIndex = this.nextOutputIndex++;
+        this.sdk('response.output_item.added', {
+            item: {
+                id,
+                type: 'message',
+                role: 'assistant',
+                status: 'in_progress',
+                content: [
+                    {
+                        type: 'output_text',
+                        text: '',
+                    },
+                ],
+            },
+        }, this.messageOutputIndex);
+    }
+    closeMessage() {
+        if (this.messageOutputIndex === null) {
+            return;
+        }
+        const index = this.messageOutputIndex;
+        this.sdk('response.output_text.done', {}, index);
+        this.sdk('response.output_item.done', {}, index);
+        this.messageOutputIndex = null;
+    }
+    emitToolCall(toolCallId, name, input) {
+        this.start();
+        const index = this.nextOutputIndex++;
+        const args = typeof input === 'string' ? input : JSON.stringify(input ?? {});
+        this.sdk('response.output_item.added', {
+            item: {
+                id: toolCallId,
+                type: 'function_call',
+                status: 'in_progress',
+                callId: toolCallId,
+                name,
+                arguments: '',
+            },
+        }, index);
+        this.sdk('response.function_call_arguments.delta', {
+            delta: args,
+        }, index);
+        this.sdk('response.function_call_arguments.done', {
+            arguments: args,
+        }, index);
+        this.sdk('response.output_item.done', {}, index);
+        this.announcedToolCalls.add(toolCallId);
+    }
+    translate(update) {
+        if (update.sessionUpdate === 'agent_message_chunk') {
+            this.openMessage();
+            this.sdk('response.output_text.delta', {
+                delta: blockText(update.content),
+            }, this.messageOutputIndex ?? 0);
+            this.sawText = true;
+            return;
+        }
+        if (update.sessionUpdate === 'agent_thought_chunk') {
+            this.start();
+            this.sdk('response.reasoning.delta', {
+                delta: blockText(update.content),
+            });
+            return;
+        }
+        if (update.sessionUpdate === 'tool_call') {
+            this.closeMessage();
+            this.emitToolCall(update.toolCallId, update.title, update.rawInput);
+            return;
+        }
+        // `user_message_chunk` (replayed history), `tool_call_update`, `plan`,
+        // `available_commands_update`, and `current_mode_update` have no model-stream
+        // analogue; they surface on the full stream under their protocol names.
+        this.sdk(`acp.${update.sessionUpdate}`, {
+            update,
+        });
+    }
+}

package/dist/interpreter/acp-history.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Gives an ACP agent the prior conversation.
+ *
+ * ACP sessions own their own history on the agent side, but a freshly opened
+ * session knows nothing about the Noetic steps that ran before it. Seeding the
+ * first prompt with a transcript of the conversation so far means a coding agent
+ * running after a chain of `callModel` steps understands what was already
+ * established instead of answering out of context.
+ */
+import type { Item } from '@noetic-tools/types';
+/** @public Render conversation history as a plain-text transcript. */
+export declare function formatConversation(items: ReadonlyArray<Item>): string;
+/**
+ * Fold the conversation so far into a turn's prompt. Returns the prompt
+ * unchanged when there is no history, so the very first step of a run is not
+ * padded with an empty preamble.
+ * @public
+ */
+export declare function withHistoryPrompt(input: {
+    prompt: string;
+    history: ReadonlyArray<Item>;
+}): string;

package/dist/interpreter/acp-history.js

@@ -0,0 +1,58 @@
+/**
+ * Gives an ACP agent the prior conversation.
+ *
+ * ACP sessions own their own history on the agent side, but a freshly opened
+ * session knows nothing about the Noetic steps that ran before it. Seeding the
+ * first prompt with a transcript of the conversation so far means a coding agent
+ * running after a chain of `callModel` steps understands what was already
+ * established instead of answering out of context.
+ */
+function roleLabel(role) {
+    if (role === 'assistant') {
+        return 'Assistant';
+    }
+    if (role === 'user') {
+        return 'User';
+    }
+    return 'System';
+}
+function messageText(item) {
+    if (item.type !== 'message') {
+        return null;
+    }
+    const text = item.content
+        .map((part) => ('text' in part && typeof part.text === 'string' ? part.text : ''))
+        .join('');
+    return text.length > 0 ? `${roleLabel(item.role)}: ${text}` : null;
+}
+/** @public Render conversation history as a plain-text transcript. */
+export function formatConversation(items) {
+    const lines = [];
+    for (const item of items) {
+        const line = messageText(item);
+        if (line) {
+            lines.push(line);
+            continue;
+        }
+        if (item.type === 'function_call') {
+            lines.push(`Assistant called ${item.name}(${item.arguments})`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Fold the conversation so far into a turn's prompt. Returns the prompt
+ * unchanged when there is no history, so the very first step of a run is not
+ * padded with an empty preamble.
+ * @public
+ */
+export function withHistoryPrompt(input) {
+    if (input.history.length === 0) {
+        return input.prompt;
+    }
+    const transcript = formatConversation(input.history);
+    if (transcript.length === 0) {
+        return input.prompt;
+    }
+    return `Conversation so far:\n${transcript}\n\nCurrent request:\n${input.prompt}`;
+}

package/dist/interpreter/collect-tools.js

@@ -43,12 +43,9 @@ function walkStep(step, out) {
             return;
         case 'runCode':
         case 'invokeTool':
-        // SubHarness steps run their own built-in tools inside the external agent;
-        // they contribute nothing to the host unified tool set.
-        case 'claude-code':
-        case 'codex':
-        case 'opencode':
-        case 'pi':
+        // An ACP agent runs its own tools inside the external agent process; it
+        // contributes nothing to the host unified tool set.
+        case 'acp-agent':
             return;
         case 'conditional':
             if (step._optimizable) {

package/dist/interpreter/execute-acp-agent.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ACP step handler: drives an external coding agent over the Agent Client
+ * Protocol for one prompt turn and folds its output back into the Noetic
+ * execution context — the ACP analogue of `executeCallModel`.
+ *
+ * Core reaches the agent only through the `@noetic-tools/types` contract, so no
+ * protocol library or agent SDK enters its dependency graph.
+ */
+import type { Context, ContextLayer, StepAcpAgent } from '@noetic-tools/types';
+export declare function executeAcpAgent<TContext, I, O>(step: StepAcpAgent<TContext, I, O>, input: I, ctx: Context<TContext>, layers?: ContextLayer[]): Promise<O>;