@code-yeongyu/senpi-agent-core 2026.10.25-4 → 2026.10.26-2

package/dist/agent-loop.js

@@ -2,9 +2,10 @@
  * Agent loop that works with AgentMessage throughout.
  * Transforms to Message[] only at the LLM call boundary.
  */
-import { createInitialSystemMessage, EventStream, getCurrentTools, getToolStateChanges, isCursorExecResolved, normalizeContext, supportsAllowedToolChoice, validateToolArguments, } from "@earendil-works/pi-ai";
+import { assistantRecords, carryAssistantCapture, getAssistantCapture, createInitialSystemMessage, EventStream, getCurrentTools, getToolStateChanges, isCursorExecResolved, isAssistantProgress, normalizeContext, supportsAllowedToolChoice, validateToolArguments, } from "@earendil-works/pi-ai";
 import { createTerminalFailureAssistantMessage, isStreamIdleTimeoutError, normalizeTerminalAssistantMessage, settleStopReason, shouldFinalizeIdleAsStop, shouldTerminateAssistantTurn, } from "./assistant-terminal-state.js";
 import { createResponseTimingRecorder } from "./response-timing.js";
+import { internalProgressSink } from "./internal-events.js";
 import { getDefaultStreamFn, withEmptyAssistantRecovery } from "./stream-fn.js";
 import { prepareAgentToolCallArguments } from "./tool-arguments.js";
 import { resolveCallTool, withToolNameCorrection } from "./tool-name-alias.js";
@@ -510,7 +511,10 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
         });
         // Record the requested level, whichever stream function answered.
         const result = async () => Object.assign(await response.result(), { thinkingLevel: config.reasoning ?? "off" });
-        const iterator = response[Symbol.asyncIterator]();
+        // Without an internal listener the loop reads the public stream exactly as before: no records, no carriers.
+        const sink = config[internalProgressSink];
+        const records = sink ? assistantRecords(response) : response;
+        const iterator = records[Symbol.asyncIterator]();
         const eventReader = createAssistantEventReader(iterator, streamIdleTimeoutMs, requestAbortController.signal, (error) => requestAbortController.abort(error), preStream.remainingStartMs(), response, normalizeTimeoutMs(config.streamStartTimeoutMs));
         try {
             while (true) {
@@ -518,16 +522,20 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                 if (next.done)
                     break;
                 const event = next.value;
+                if (isAssistantProgress(event)) {
+                    await sink?.(event);
+                    continue;
+                }
                 switch (event.type) {
                     case "start":
                         responseTiming.started();
                         partialMessage = event.partial;
                         context.messages.push(partialMessage);
                         addedPartial = true;
-                        await emit({
+                        await emit(carryAssistantCapture(event, {
                             type: "message_start",
                             message: { ...partialMessage },
-                        });
+                        }));
                         break;
                     case "text_start":
                     case "text_delta":
@@ -541,6 +549,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                         if (partialMessage) {
                             partialMessage = event.partial;
                             responseTiming.observe(event);
+                            let timingProgress;
                             if (event.type === "thinking_start" ||
                                 event.type === "thinking_delta" ||
                                 event.type === "thinking_end") {
@@ -556,14 +565,23 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                                     block.startedAt = timing.startedAt;
                                     if (timing.endedAt !== undefined)
                                         block.endedAt = timing.endedAt;
+                                    // Stamped after provider capture: it amends this event's seed or end block, so it follows it.
+                                    if (getAssistantCapture(event) && event.type !== "thinking_delta")
+                                        timingProgress = Object.freeze({
+                                            type: "message_block_metadata",
+                                            contentIndex: event.contentIndex,
+                                            ...timing,
+                                        });
                                 }
                             }
                             context.messages[context.messages.length - 1] = partialMessage;
-                            await emit({
+                            await emit(carryAssistantCapture(event, {
                                 type: "message_update",
                                 assistantMessageEvent: event,
                                 message: { ...partialMessage },
-                            });
+                            }));
+                            if (timingProgress)
+                                await sink?.(timingProgress);
                         }
                         break;
                     case "done":
@@ -577,12 +595,12 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                             context.messages.push(finalMessage);
                         }
                         if (!addedPartial) {
-                            await emit({
+                            await emit(carryAssistantCapture(event, {
                                 type: "message_start",
                                 message: { ...finalMessage },
-                            });
+                            }, finalMessage));
                         }
-                        await emit({ type: "message_end", message: finalMessage });
+                        await emit(carryAssistantCapture(event, { type: "message_end", message: finalMessage }, finalMessage));
                         return { message: finalMessage, providerToolResults };
                     }
                 }
@@ -749,6 +767,8 @@ configuredStartTimeoutMs) {
     const startTimeoutMs = normalizeTimeoutMs(streamStartTimeoutMs);
     const reportedStartTimeoutMs = configuredStartTimeoutMs ?? startTimeoutMs;
     let sawFirstEvent = false;
+    // Provider silence since the last public event: internal progress records re-arm neither bound.
+    let silentMs = 0;
     let removeAbortListener;
     let abortPromise;
     if (signal !== undefined) {
@@ -775,10 +795,16 @@ configuredStartTimeoutMs) {
             const readTimeoutMs = useStartBound ? startTimeoutMs : idleTimeoutMs;
             const makeTimeoutError = useStartBound
                 ? (ms) => new StreamStartTimeoutError(reportedStartTimeoutMs ?? ms)
-                : (ms) => new StreamIdleTimeoutError(ms);
-            const result = await readNextAssistantEvent(iterator, readTimeoutMs, makeTimeoutError, abortPromise, onIdleTimeout, stream, signal);
-            if (!result.done)
-                sawFirstEvent = true;
+                : (ms) => new StreamIdleTimeoutError(idleTimeoutMs ?? ms);
+            const readStartedAt = Date.now();
+            const result = await readNextAssistantEvent(iterator, readTimeoutMs === undefined ? undefined : Math.max(1, readTimeoutMs - silentMs), makeTimeoutError, abortPromise, onIdleTimeout, stream, signal);
+            if (!result.done && isAssistantProgress(result.value))
+                silentMs += Date.now() - readStartedAt;
+            else {
+                silentMs = 0;
+                if (!result.done)
+                    sawFirstEvent = true;
+            }
             return result;
         },
         dispose: () => removeAbortListener?.(),

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,6 +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 { isLocalFailure, localFailurePort } from "./local-failure.js";
 import { getDefaultStreamFn } from "./stream-fn.js";
 function defaultConvertToLlm(messages) {
@@ -131,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);
     }
@@ -138,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;
@@ -458,6 +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.#internalChannel),
             model: this._state.model,
             reasoning: reasoning === "off" ? undefined : reasoning,
             thinkingSelection: this._state.thinkingSelection,
@@ -653,6 +657,9 @@ export class Agent {
         if (!signal) {
             throw new Error("Agent listener invoked outside active run");
         }
+        const internal = dispatchInternalAgent(this.#internalChannel, { event });
+        if (internal)
+            await internal;
         for (const listener of this.listeners) {
             await listener(event, signal);
         }

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

@@ -0,0 +1,34 @@
+import { type AssistantProgress } from "@earendil-works/pi-ai";
+import type { AgentEvent, AgentLoopConfig } from "./types.ts";
+export declare const internalProgressSink: unique symbol;
+type ProgressSink = (progress: AssistantProgress) => Promise<void> | undefined;
+export type InternalLoopConfig = AgentLoopConfig & {
+    [internalProgressSink]?: ProgressSink;
+};
+type InternalEvent = {
+    event: AgentEvent;
+} | {
+    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;
+}
+/**
+ * @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 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(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(channel: InternalAgentChannel | undefined, event: InternalEvent): Promise<void> | undefined;
+export {};
+//# sourceMappingURL=internal-events.d.ts.map

package/dist/internal-events.js

@@ -0,0 +1,44 @@
+import { subscribeAssistantCapture } from "@earendil-works/pi-ai";
+export const internalProgressSink = Symbol("internalProgressSink");
+const channels = new WeakMap();
+/**
+ * @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 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(channel) {
+    if (!channel || !channels.get(channel)?.listeners.size)
+        return {};
+    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(channel, event) {
+    const state = channel && channels.get(channel);
+    if (!state?.listeners.size)
+        return undefined;
+    const record = Object.freeze({ ...event, sequence: ++state.sequence });
+    return (async () => {
+        for (const listener of state.listeners)
+            await listener(record);
+    })();
+}
+//# sourceMappingURL=internal-events.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-agent-core",
-	"version": "2026.10.25-4",
+	"version": "2026.10.26-2",
 	"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.25-4",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.25-4",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.26-2",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.26-2",
 		"diff": "9.0.0",
 		"ignore": "7.0.9",
 		"typebox": "1.3.34",