@code-yeongyu/senpi-agent-core 2026.10.31-2 → 2026.11.2-1

package/dist/agent-loop.js

@@ -99,7 +99,10 @@ export class StreamStartTimeoutError extends Error {
  */
 async function runLoop(initialContext, newMessages, initialConfig, signal, emit, streamFunction) {
     let currentContext = initialContext;
-    let config = initialConfig;
+    let config = {
+        ...initialConfig,
+        executionScope: initialConfig.executionScope ?? { id: crypto.randomUUID(), root: "" },
+    };
     let firstTurn = true;
     let firstProviderRequest = true;
     let drainedTerminatingQueue;
@@ -922,10 +925,28 @@ async function executeToolCalls(currentContext, assistantMessage, config, signal
     // channel and its result buffered; running it again would duplicate a
     // side-effecting tool.
     const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall" && !isCursorExecResolved(c));
-    if (config.toolExecution === "sequential") {
-        return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
-    }
-    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    const host = config.toolHost ?? {
+        execute: async (call, options) => {
+            // Only yield when a witness sink is configured and returns a promise: an unconditional `await` adds a
+            // microtask per call and reorders lifecycle vs message events against today's fused path (EQ E03).
+            const recordWitness = options.recordWitness;
+            if (recordWitness) {
+                for (const raw of call.calls) {
+                    const pending = recordWitness({ pipeline: "legacy", toolCallId: raw.id });
+                    if (pending)
+                        await pending;
+                }
+            }
+            return call.mode === "sequential"
+                ? executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, options.signal, options.emit)
+                : executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, options.signal, options.emit);
+        },
+    };
+    return host.execute({
+        scope: config.executionScope ?? { id: crypto.randomUUID(), root: "" },
+        calls: toolCalls,
+        mode: config.toolExecution ?? "parallel",
+    }, { signal, emit, recordWitness: config.onExecutionPipeline });
 }
 async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
     const finalizedCalls = [];

package/dist/agent.d.ts

@@ -37,6 +37,9 @@ export interface AgentOptions {
     streamKeepAliveTimeoutMs?: number;
     maxRetryDelayMs?: number;
     toolExecution?: ToolExecutionMode;
+    toolHost?: AgentLoopConfig["toolHost"];
+    executionScope?: AgentLoopConfig["executionScope"];
+    onExecutionPipeline?: AgentLoopConfig["onExecutionPipeline"];
     removedToolHints?: Record<string, string>;
     resolveUnknownToolCall?: AgentLoopConfig["resolveUnknownToolCall"];
     abortServerSideFallback?: boolean;
@@ -113,6 +116,10 @@ export declare class Agent {
     maxRetryDelayMs?: number;
     /** Tool execution strategy for assistant messages that contain multiple tool calls. */
     toolExecution: ToolExecutionMode;
+    toolHost?: AgentLoopConfig["toolHost"];
+    executionScope: NonNullable<AgentLoopConfig["executionScope"]>;
+    getExecutionScope?: () => NonNullable<AgentLoopConfig["executionScope"]>;
+    onExecutionPipeline?: AgentLoopConfig["onExecutionPipeline"];
     /** Migration guidance returned when a removed tool name is called. */
     removedToolHints: Record<string, string>;
     /** Optional call-time resolver for tools absent from the request context. */

package/dist/agent.js

@@ -167,6 +167,9 @@ export class Agent {
         this.streamKeepAliveTimeoutMs = runtimeOptions.streamKeepAliveTimeoutMs;
         this.maxRetryDelayMs = runtimeOptions.maxRetryDelayMs;
         this.toolExecution = runtimeOptions.toolExecution ?? "parallel";
+        this.toolHost = runtimeOptions.toolHost;
+        this.executionScope = runtimeOptions.executionScope ?? { id: crypto.randomUUID(), root: "" };
+        this.onExecutionPipeline = runtimeOptions.onExecutionPipeline;
         this.removedToolHints = runtimeOptions.removedToolHints ?? {};
         this.resolveUnknownToolCall = runtimeOptions.resolveUnknownToolCall;
         this.abortServerSideFallback = runtimeOptions.abortServerSideFallback;
@@ -485,6 +488,9 @@ export class Agent {
             abortServerSideFallback: this.abortServerSideFallback,
             cursorExecHandlers: this.cursorExecHandlers,
             toolExecution: this.toolExecution,
+            toolHost: this.toolHost,
+            executionScope: this.getExecutionScope?.() ?? this.executionScope,
+            onExecutionPipeline: this.onExecutionPipeline,
             removedToolHints: this.removedToolHints,
             resolveUnknownToolCall: this.resolveUnknownToolCall,
             beforeToolCall: this.beforeToolCall,

package/dist/conformance/loop-core-manifest.d.ts

@@ -0,0 +1,14 @@
+/**
+ * S06: the host-independent loop boundary, relative to packages/agent/src.
+ * Every local dependency (including type imports) must also be listed and checked.
+ * Host adapters, carriers, persistence implementations and the Node harness stay outside.
+ * Extend this closure when adding loop modules; never add a host implementation to it.
+ */
+export declare const LOOP_CORE_MODULES: readonly ["agent.ts", "agent-loop.ts", "assistant-terminal-state.ts", "empty-assistant-recovery.ts", "internal-events.ts", "local-failure.ts", "response-timing.ts", "stream-fn.ts", "stream-keepalive.ts", "tool-arguments.ts", "tool-name-alias.ts", "types.ts", "durable/store.ts", "execution/tool-host.ts", "durable/store-admission.ts", "durable/wake-host.ts", "transport/transport.ts"];
+/**
+ * Existing portable model/message utilities and schema types, not provider runtimes.
+ * Exact specifiers deliberately exclude compat, OAuth, SDKs and host-specific subpaths.
+ * The model implementation enters the loop through StreamFn, not a provider import.
+ */
+export declare const LOOP_CORE_EXTERNAL_MODULES: readonly ["@earendil-works/pi-ai", "@earendil-works/pi-ai/utils/oauth-refresh-error", "@earendil-works/pi-ai/utils/retry", "@earendil-works/pi-ai/utils/tool-name-match", "typebox"];
+//# sourceMappingURL=loop-core-manifest.d.ts.map

package/dist/conformance/loop-core-manifest.js

@@ -0,0 +1,38 @@
+/**
+ * S06: the host-independent loop boundary, relative to packages/agent/src.
+ * Every local dependency (including type imports) must also be listed and checked.
+ * Host adapters, carriers, persistence implementations and the Node harness stay outside.
+ * Extend this closure when adding loop modules; never add a host implementation to it.
+ */
+export const LOOP_CORE_MODULES = [
+    "agent.ts",
+    "agent-loop.ts",
+    "assistant-terminal-state.ts",
+    "empty-assistant-recovery.ts",
+    "internal-events.ts",
+    "local-failure.ts",
+    "response-timing.ts",
+    "stream-fn.ts",
+    "stream-keepalive.ts",
+    "tool-arguments.ts",
+    "tool-name-alias.ts",
+    "types.ts",
+    "durable/store.ts",
+    "execution/tool-host.ts",
+    "durable/store-admission.ts",
+    "durable/wake-host.ts",
+    "transport/transport.ts",
+];
+/**
+ * Existing portable model/message utilities and schema types, not provider runtimes.
+ * Exact specifiers deliberately exclude compat, OAuth, SDKs and host-specific subpaths.
+ * The model implementation enters the loop through StreamFn, not a provider import.
+ */
+export const LOOP_CORE_EXTERNAL_MODULES = [
+    "@earendil-works/pi-ai",
+    "@earendil-works/pi-ai/utils/oauth-refresh-error",
+    "@earendil-works/pi-ai/utils/retry",
+    "@earendil-works/pi-ai/utils/tool-name-match",
+    "typebox",
+];
+//# sourceMappingURL=loop-core-manifest.js.map

package/dist/execution/tool-host.d.ts

@@ -0,0 +1,32 @@
+import type { ToolResultMessage } from "@earendil-works/pi-ai";
+import type { AgentEvent, AgentToolCall, ToolExecutionMode } from "../types.ts";
+/** Brain-minted identity and execution root; the executor treats the identity as opaque. */
+export interface ExecutionScope {
+    readonly id: string;
+    readonly root: string;
+}
+/** The raw model calls, before name resolution, argument preparation, validation or hooks. */
+export interface ToolHostCall {
+    readonly scope: ExecutionScope;
+    readonly calls: readonly AgentToolCall[];
+    readonly mode: ToolExecutionMode;
+}
+export interface ExecutionPipelineWitness {
+    readonly pipeline: "legacy" | "prepared";
+    readonly toolCallId: string;
+}
+export interface ToolHostResult {
+    readonly messages: ToolResultMessage[];
+    readonly terminate: boolean;
+}
+export interface ToolHostOptions {
+    readonly signal?: AbortSignal;
+    /** Preserve tool events and ordered result-message events. The loop appends the returned messages to context. */
+    readonly emit: (event: AgentEvent) => Promise<void> | void;
+    /** Receipt metadata only: never an AgentEvent, tool result, provider payload or EQ observable. */
+    readonly recordWitness?: (witness: ExecutionPipelineWitness) => Promise<void> | void;
+}
+export interface ToolHost {
+    execute(call: ToolHostCall, options: ToolHostOptions): Promise<ToolHostResult>;
+}
+//# sourceMappingURL=tool-host.d.ts.map

package/dist/execution/tool-host.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-host.js.map

package/dist/types.d.ts

@@ -1,5 +1,7 @@
 import type { Api, AssistantMessage, AssistantMessageEvent, AssistantMessageEventStream, CursorExecHandlers, ImageContent, JsonValue, Message, Model, ProviderDiagnostic, SimpleStreamOptions, TextContent, ThinkingSelection, Tool, ToolResultMessage, TranscriptContext, Usage } from "@earendil-works/pi-ai";
 import type { Static, TSchema } from "typebox";
+import type { ExecutionPipelineWitness, ExecutionScope, ToolHost } from "./execution/tool-host.ts";
+export type { ExecutionPipelineWitness, ExecutionScope, ToolHost, ToolHostCall, ToolHostOptions, ToolHostResult, } from "./execution/tool-host.ts";
 /**
  * Stream function used by the agent loop. `Models.streamSimple` satisfies
  * this shape.
@@ -322,6 +324,10 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * Default: "parallel"
      */
     toolExecution?: ToolExecutionMode;
+    /** Unprepared batch boundary. Omitted selects the existing in-process legacy scheduler. */
+    toolHost?: ToolHost;
+    executionScope?: ExecutionScope;
+    onExecutionPipeline?: (witness: ExecutionPipelineWitness) => Promise<void> | void;
     /**
      * Optional migration guidance for tool names intentionally removed by an extension.
      * The matching hint is appended to the normal unknown-tool error before hooks run.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-agent-core",
-	"version": "2026.10.31-2",
+	"version": "2026.11.02-1",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -70,8 +70,8 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.31-2",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.31-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.11.02-1",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.11.02-1",
 		"diff": "9.0.0",
 		"ignore": "7.0.9",
 		"typebox": "1.3.34",