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

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.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) {
@@ -458,6 +459,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),
             model: this._state.model,
             reasoning: reasoning === "off" ? undefined : reasoning,
             thinkingSelection: this._state.thinkingSelection,
@@ -653,6 +655,9 @@ export class Agent {
         if (!signal) {
             throw new Error("Agent listener invoked outside active run");
         }
+        const internal = dispatchInternalAgent(this, { event });
+        if (internal)
+            await internal;
         for (const listener of this.listeners) {
             await listener(event, signal);
         }

package/dist/internal-events.d.ts

@@ -0,0 +1,29 @@
+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;
+};
+export type OrderedAgentRecord = InternalEvent & {
+    readonly sequence: number;
+};
+type Listener = (record: OrderedAgentRecord) => Promise<void> | 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.
+ */
+export declare function subscribeInternalAgent(owner: object, listener: Listener): () => void;
+/** 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): {
+    [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 {};
+//# sourceMappingURL=internal-events.d.ts.map

package/dist/internal-events.js

@@ -0,0 +1,38 @@
+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.
+ */
+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();
+    };
+}
+/** 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)
+        return {};
+    return { [internalProgressSink]: (progress) => dispatchInternalAgent(owner, { 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)
+        return undefined;
+    const record = Object.freeze({ ...event, sequence: ++channel.sequence });
+    return (async () => {
+        for (const listener of channel.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-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.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-1",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.26-1",
 		"diff": "9.0.0",
 		"ignore": "7.0.9",
 		"typebox": "1.3.34",