@code-yeongyu/senpi-agent-core 2026.10.26-1 → 2026.10.27-1

package/dist/agent.d.ts

@@ -1,4 +1,5 @@
 import { type ImageContent, type Message, type SimpleStreamOptions, type ThinkingBudgets, type TranscriptContext, type Transport } from "@earendil-works/pi-ai";
+import { type InternalAgentChannel } from "./internal-events.ts";
 import type { AfterToolCallContext, AfterToolCallResult, AgentContext, AgentEvent, AgentLoopConfig, AgentLoopTurnUpdate, AgentMessage, AgentState, BeforeToolCallContext, BeforeToolCallResult, FinishTurn, PrepareNextTurnContext, PrepareRequest, QueueMode, StreamFn, ToolExecutionMode } from "./types.ts";
 export type { QueueMode } from "./types.ts";
 /**
@@ -8,6 +9,8 @@ export type { QueueMode } from "./types.ts";
 export type AgentInitialState = Partial<Omit<AgentState, "pendingToolCalls" | "isStreaming" | "streamingMessage" | "errorMessage" | "providerDiagnostic">>;
 /** Options for constructing an {@link Agent}. */
 export interface AgentOptions {
+    /** @internal Construction-time channel for senpi's session layer only. */
+    internalChannel?: InternalAgentChannel;
     initialState?: AgentInitialState;
     convertToLlm?: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
     transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
@@ -74,6 +77,7 @@ export interface AgentContinuationOptions {
  * and exposes queueing APIs for steering and follow-up messages.
  */
 export declare class Agent {
+    #private;
     private _state;
     private readonly listeners;
     private readonly steeringQueue;

package/dist/agent.js

@@ -1,7 +1,7 @@
 import { readProviderDiagnostic, sanitizeProviderDiagnostic, } from "@earendil-works/pi-ai";
 import { buildProviderContext as buildProviderContextFromAgentContext, runAgentLoop, runAgentLoopContinue, } from "./agent-loop.js";
 import { ProviderRetryWatchdogAbortError } from "./assistant-terminal-state.js";
-import { dispatchInternalAgent, internalLoopSink } from "./internal-events.js";
+import { dispatchInternalAgent, internalLoopSink, } from "./internal-events.js";
 import { isLocalFailure, localFailurePort } from "./local-failure.js";
 import { getDefaultStreamFn } from "./stream-fn.js";
 function defaultConvertToLlm(messages) {
@@ -132,6 +132,7 @@ class PendingMessageQueue {
  * and exposes queueing APIs for steering and follow-up messages.
  */
 export class Agent {
+    #internalChannel;
     async buildProviderContext(context, signal) {
         return buildProviderContextFromAgentContext(context, { convertToLlm: this.convertToLlm, transformContext: this.transformContext, model: this._state.model }, signal);
     }
@@ -139,6 +140,7 @@ export class Agent {
         this.listeners = new Set();
         // Older compiled consumers may omit options or streamFn even though the current API requires them.
         const runtimeOptions = options ?? {};
+        this.#internalChannel = runtimeOptions.internalChannel;
         this._state = createMutableAgentState(runtimeOptions.initialState);
         this.convertToLlm = runtimeOptions.convertToLlm ?? defaultConvertToLlm;
         this.transformContext = runtimeOptions.transformContext;
@@ -459,7 +461,7 @@ export class Agent {
         const giveBack = (queue, messages) => this.giveBack(queue, messages, queue === "steering" ? steeringQueueGeneration : followUpQueueGeneration);
         const reasoning = this._state.reasoningBaseline ?? this._state.thinkingLevel;
         return {
-            ...internalLoopSink(this),
+            ...internalLoopSink(this.#internalChannel),
             model: this._state.model,
             reasoning: reasoning === "off" ? undefined : reasoning,
             thinkingSelection: this._state.thinkingSelection,
@@ -655,7 +657,7 @@ export class Agent {
         if (!signal) {
             throw new Error("Agent listener invoked outside active run");
         }
-        const internal = dispatchInternalAgent(this, { event });
+        const internal = dispatchInternalAgent(this.#internalChannel, { event });
         if (internal)
             await internal;
         for (const listener of this.listeners) {

package/dist/empty-assistant-recovery.js

@@ -1,4 +1,4 @@
-import { createAssistantMessageEventStream, EMPTY_RESPONSE_ERROR, EMPTY_TOOL_USE_ERROR, FORWARDED_EMPTY_RESPONSE_ERROR, FORWARDED_EMPTY_TOOL_USE_ERROR, getToolCallFormat, hasKimiTextToolCallRecovery, hasVisibleAssistantContent, hasVisibleText, shouldRecoverTextToolCalls, } from "@earendil-works/pi-ai";
+import { assistantEvents, carryAssistantCapture, createAssistantMessageEventStream, EMPTY_RESPONSE_ERROR, EMPTY_TOOL_USE_ERROR, FORWARDED_EMPTY_RESPONSE_ERROR, FORWARDED_EMPTY_TOOL_USE_ERROR, getToolCallFormat, hasKimiTextToolCallRecovery, hasVisibleAssistantContent, hasVisibleText, pushAssistantProgress, shouldRecoverTextToolCalls, } from "@earendil-works/pi-ai";
 function isEmptyStop(message) {
     return message.stopReason === "stop" && !hasVisibleAssistantContent(message);
 }
@@ -56,24 +56,34 @@ function createForwardedEmptyFailure(message, toolUse) {
 }
 function createRetryingStream(firstStream, createStream, policy) {
     const outerStream = createAssistantMessageEventStream();
+    const forward = (entry) => {
+        if ("event" in entry)
+            outerStream.push(entry.event);
+        else
+            pushAssistantProgress(outerStream, entry.progress);
+    };
+    const replaced = (source, error) => carryAssistantCapture(source, { type: "error", reason: "error", error }, error);
     void (async () => {
         try {
             let stream = firstStream;
             let retrying = false;
             for (;;) {
+                // Controls are held beside the events they follow, so a discarded attempt discards both.
                 const buffered = [];
                 let forwarding = false;
                 let retry = false;
-                for await (const event of stream) {
+                const events = assistantEvents(stream, (progress) => {
+                    if (forwarding)
+                        pushAssistantProgress(outerStream, progress);
+                    else
+                        buffered.push({ progress });
+                });
+                for await (const event of events) {
                     if (event.type === "done") {
                         const emptyToolUse = isEmptyToolUse(event.message);
                         if (isEmptyStop(event.message) || emptyToolUse) {
                             if (forwarding) {
-                                outerStream.push({
-                                    type: "error",
-                                    reason: "error",
-                                    error: createForwardedEmptyFailure(event.message, emptyToolUse),
-                                });
+                                outerStream.push(replaced(event, createForwardedEmptyFailure(event.message, emptyToolUse)));
                                 outerStream.end();
                                 return;
                             }
@@ -81,20 +91,17 @@ function createRetryingStream(firstStream, createStream, policy) {
                                 retry = true;
                                 break;
                             }
-                            const error = createEmptyResponseFailure(event.message, emptyToolUse);
-                            outerStream.push({ type: "error", reason: "error", error });
+                            outerStream.push(replaced(event, createEmptyResponseFailure(event.message, emptyToolUse)));
                             outerStream.end();
                             return;
                         }
-                        const terminal = retrying
-                            ? {
-                                ...event,
-                                message: appendRetryDiagnostic(event.message, recoveryDiagnosticType(isEmptyToolUse(event.message))),
-                            }
-                            : event;
+                        const message = retrying
+                            ? appendRetryDiagnostic(event.message, recoveryDiagnosticType(isEmptyToolUse(event.message)))
+                            : event.message;
+                        const terminal = retrying ? carryAssistantCapture(event, { ...event, message }, message) : event;
                         if (!forwarding) {
                             for (const pending of buffered)
-                                outerStream.push(pending);
+                                forward(pending);
                         }
                         outerStream.push(terminal);
                         outerStream.end();
@@ -103,7 +110,7 @@ function createRetryingStream(firstStream, createStream, policy) {
                     if (event.type === "error") {
                         if (!forwarding) {
                             for (const pending of buffered)
-                                outerStream.push(pending);
+                                forward(pending);
                         }
                         outerStream.push(event);
                         outerStream.end();
@@ -113,10 +120,10 @@ function createRetryingStream(firstStream, createStream, policy) {
                         outerStream.push(event);
                         continue;
                     }
-                    buffered.push(event);
+                    buffered.push({ event });
                     if (isMeaningfulContentEvent(event, policy)) {
                         for (const pending of buffered)
-                            outerStream.push(pending);
+                            forward(pending);
                         forwarding = true;
                     }
                 }

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type { AttributeValue, ExactTelemetryAttributes, InferEventAttributes, In
 export { createTypedSpanStarter, defineTelemetrySchema, InMemoryTelemetryContext, NOOP_TELEMETRY_CONTEXT, } from "@earendil-works/pi-telemetry";
 export * from "./agent.ts";
 export * from "./agent-loop.ts";
+export { createInternalAgentChannel, type InternalAgentChannel, type OrderedAgentRecord } from "./internal-events.ts";
 export { EMPTY_TOOL_USE_DEMOTION_DIAGNOSTIC, ProviderRetryWatchdogAbortError } from "./assistant-terminal-state.ts";
 export * from "./harness/agent-harness.ts";
 export { type BranchPreparation, type BranchSummaryDetails, type BranchSummaryResult, type CollectEntriesResult, collectEntriesForBranchSummary, type FileOperations, type GenerateBranchSummaryOptions, generateBranchSummary, prepareBranchEntries, } from "./harness/compaction/branch-summarization.ts";

package/dist/index.js

@@ -2,6 +2,7 @@ export { uuidv7 } from "@earendil-works/pi-ai";
 export { createTypedSpanStarter, defineTelemetrySchema, InMemoryTelemetryContext, NOOP_TELEMETRY_CONTEXT, } from "@earendil-works/pi-telemetry";
 export * from "./agent.js";
 export * from "./agent-loop.js";
+export { createInternalAgentChannel } from "./internal-events.js";
 export { EMPTY_TOOL_USE_DEMOTION_DIAGNOSTIC, ProviderRetryWatchdogAbortError } from "./assistant-terminal-state.js";
 export * from "./harness/agent-harness.js";
 export { collectEntriesForBranchSummary, generateBranchSummary, prepareBranchEntries, } from "./harness/compaction/branch-summarization.js";

package/dist/internal-events.d.ts

@@ -10,20 +10,25 @@ type InternalEvent = {
 } | {
     progress: AssistantProgress;
 };
+/** @internal For senpi's session layer only. */
 export type OrderedAgentRecord = InternalEvent & {
     readonly sequence: number;
 };
 type Listener = (record: OrderedAgentRecord) => Promise<void> | void;
+/** @internal Construction-time capability for senpi's session layer only. */
+export interface InternalAgentChannel {
+    subscribe(listener: Listener): () => void;
+}
 /**
- * S02a owner seam: deliberately not exported by the package barrel or subscribed by a host.
- * A listener holds a capture subscription, so provider streams that first push after it build capture records.
+ * @internal For senpi's session layer only. Pass at Agent construction; an existing Agent cannot be attached.
+ * Capture is held from the first listener until the last release, never by an idle channel.
  */
-export declare function subscribeInternalAgent(owner: object, listener: Listener): () => void;
+export declare function createInternalAgentChannel(): InternalAgentChannel;
 /** A run started without an internal listener gets no sink, and its loop reads the public stream exactly as before. */
-export declare function internalLoopSink(owner: object): {
+export declare function internalLoopSink(channel: InternalAgentChannel | undefined): {
     [internalProgressSink]?: ProgressSink;
 };
 /** Returns nothing, so it costs the public pipeline no microtask, while the owner has no internal listener. */
-export declare function dispatchInternalAgent(owner: object, event: InternalEvent): Promise<void> | undefined;
+export declare function dispatchInternalAgent(channel: InternalAgentChannel | undefined, event: InternalEvent): Promise<void> | undefined;
 export {};
 //# sourceMappingURL=internal-events.d.ts.map

package/dist/internal-events.js

@@ -2,36 +2,42 @@ import { subscribeAssistantCapture } from "@earendil-works/pi-ai";
 export const internalProgressSink = Symbol("internalProgressSink");
 const channels = new WeakMap();
 /**
- * S02a owner seam: deliberately not exported by the package barrel or subscribed by a host.
- * A listener holds a capture subscription, so provider streams that first push after it build capture records.
+ * @internal For senpi's session layer only. Pass at Agent construction; an existing Agent cannot be attached.
+ * Capture is held from the first listener until the last release, never by an idle channel.
  */
-export function subscribeInternalAgent(owner, listener) {
-    let channel = channels.get(owner);
-    if (!channel) {
-        channel = { sequence: 0, listeners: new Set() };
-        channels.set(owner, channel);
-    }
-    channel.listeners.add(listener);
-    const release = subscribeAssistantCapture();
-    return () => {
-        channel.listeners.delete(listener);
-        release();
-    };
+export function createInternalAgentChannel() {
+    const state = { sequence: 0, listeners: new Set() };
+    let releaseCapture;
+    const channel = Object.freeze({
+        subscribe(listener) {
+            state.listeners.add(listener);
+            releaseCapture ??= subscribeAssistantCapture();
+            return () => {
+                state.listeners.delete(listener);
+                if (state.listeners.size === 0) {
+                    releaseCapture?.();
+                    releaseCapture = undefined;
+                }
+            };
+        },
+    });
+    channels.set(channel, state);
+    return channel;
 }
 /** A run started without an internal listener gets no sink, and its loop reads the public stream exactly as before. */
-export function internalLoopSink(owner) {
-    if (!channels.get(owner)?.listeners.size)
+export function internalLoopSink(channel) {
+    if (!channel || !channels.get(channel)?.listeners.size)
         return {};
-    return { [internalProgressSink]: (progress) => dispatchInternalAgent(owner, { progress }) };
+    return { [internalProgressSink]: (progress) => dispatchInternalAgent(channel, { progress }) };
 }
 /** Returns nothing, so it costs the public pipeline no microtask, while the owner has no internal listener. */
-export function dispatchInternalAgent(owner, event) {
-    const channel = channels.get(owner);
-    if (!channel?.listeners.size)
+export function dispatchInternalAgent(channel, event) {
+    const state = channel && channels.get(channel);
+    if (!state?.listeners.size)
         return undefined;
-    const record = Object.freeze({ ...event, sequence: ++channel.sequence });
+    const record = Object.freeze({ ...event, sequence: ++state.sequence });
     return (async () => {
-        for (const listener of channel.listeners)
+        for (const listener of state.listeners)
             await listener(record);
     })();
 }

package/package.json

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