@code-yeongyu/senpi-agent-core 2026.10.21-1 → 2026.10.21-3

package/dist/agent-loop.js

@@ -4,6 +4,7 @@
  */
 import { createInitialSystemMessage, EventStream, getCurrentTools, getToolStateChanges, isCursorExecResolved, normalizeContext, supportsAllowedToolChoice, validateToolArguments, } from "@earendil-works/pi-ai";
 import { createTerminalFailureAssistantMessage, demoteToolUseWithoutToolCalls, isStreamIdleTimeoutError, normalizeTerminalAssistantMessage, promoteStopWithPendingToolCalls, shouldFinalizeIdleAsStop, shouldTerminateAssistantTurn, } from "./assistant-terminal-state.js";
+import { createResponseTimingRecorder } from "./response-timing.js";
 import { getDefaultStreamFn, withEmptyAssistantRecovery } from "./stream-fn.js";
 import { prepareAgentToolCallArguments } from "./tool-arguments.js";
 import { resolveCallTool, withToolNameCorrection } from "./tool-name-alias.js";
@@ -445,7 +446,9 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
     // after the assistant message so pairs stay adjacent in the transcript.
     const providerToolResults = [];
     const thinkingTiming = new Map();
-    function propagateThinkingTiming(finalMessage) {
+    const responseTiming = createResponseTimingRecorder();
+    function stampTiming(finalMessage) {
+        responseTiming.stamp(finalMessage);
         for (const timing of thinkingTiming.values()) {
             if (timing.endedAt === undefined)
                 timing.endedAt = Date.now();
@@ -480,6 +483,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
         const llmContext = await preStream.run(buildProviderContext(context, config, requestAbortController.signal));
         // Resolve API key (important for expiring tokens)
         const resolvedApiKey = (config.getApiKey ? await preStream.run(config.getApiKey(config.model.provider)) : undefined) || config.apiKey;
+        responseTiming.requested();
         const response = await preStream.run(streamFunction(config.model, llmContext, {
             ...config,
             streamKind: "main",
@@ -516,6 +520,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                 const event = next.value;
                 switch (event.type) {
                     case "start":
+                        responseTiming.started();
                         partialMessage = event.partial;
                         context.messages.push(partialMessage);
                         addedPartial = true;
@@ -535,6 +540,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                     case "toolcall_end":
                         if (partialMessage) {
                             partialMessage = event.partial;
+                            responseTiming.observe(event);
                             if (event.type === "thinking_start" ||
                                 event.type === "thinking_delta" ||
                                 event.type === "thinking_end") {
@@ -563,7 +569,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                     case "done":
                     case "error": {
                         const finalMessage = normalizeTerminalAssistantMessage(await result(), event);
-                        propagateThinkingTiming(finalMessage);
+                        stampTiming(finalMessage);
                         if (addedPartial) {
                             context.messages[context.messages.length - 1] = finalMessage;
                         }
@@ -586,7 +592,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
             eventReader.dispose();
         }
         const finalMessage = await result();
-        propagateThinkingTiming(finalMessage);
+        stampTiming(finalMessage);
         if (addedPartial) {
             context.messages[context.messages.length - 1] = finalMessage;
         }
@@ -619,7 +625,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                 stopReason: "stop",
                 timestamp: partialMessage?.timestamp ?? Date.now(),
             };
-            propagateThinkingTiming(finalMessage);
+            stampTiming(finalMessage);
             if (addedPartial) {
                 context.messages[context.messages.length - 1] = finalMessage;
             }
@@ -637,7 +643,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
         const callerAbortedPastBound = signal?.aborted === true &&
             (error instanceof StreamStartTimeoutError || isStreamIdleTimeoutError(error) || error === signal.reason);
         const finalMessage = createTerminalFailureAssistantMessage(config.model, signal?.aborted ? "aborted" : "error", callerAbortedPastBound ? abortError(signal.reason) : error, partialMessage);
-        propagateThinkingTiming(finalMessage);
+        stampTiming(finalMessage);
         if (addedPartial) {
             context.messages[context.messages.length - 1] = finalMessage;
         }

package/dist/harness/compaction/compaction.js

@@ -79,6 +79,9 @@ export const DEFAULT_COMPACTION_SETTINGS = {
 };
 /** Calculate total context tokens from provider usage. */
 export function calculateContextTokens(usage) {
+    if (usage.contextUsage !== undefined) {
+        return usage.contextUsage === null ? 0 : usage.contextUsage.input + usage.contextUsage.output;
+    }
     return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
 }
 function getAssistantUsage(msg) {

package/dist/harness/pico3/harness.d.ts

@@ -96,7 +96,11 @@ export declare class Harness<Ks extends readonly AnyKind[] = []> {
     private reconcileOrphans;
     quiescent(): boolean;
     hold(): () => void;
-    /** Cancel and join in-process invocations, clear transient waits, then close without terminalizing tasks. */
+    /**
+     * Cancel and join in-process invocations, clear transient waits, then close without terminalizing tasks.
+     * The views and the session are closed even when joining or the waiting-state commit fails (a storage
+     * that refuses writes), so a failed suspend never leaks the session files; the first error is rethrown.
+     */
     suspend(ctx: Context): Promise<void>;
     registerTaskKind<K extends AnyKind>(kind: K): () => void;
     namespace<T extends JsonObject>(id: string, defaults: NamespaceDefaults<T>, opts?: {

package/dist/harness/pico3/harness.js

@@ -266,26 +266,43 @@ export class Harness {
             throw new Error("cannot hold a non-quiescent harness; suspend it instead");
         return this.scheduler.hold();
     }
-    /** Cancel and join in-process invocations, clear transient waits, then close without terminalizing tasks. */
+    /**
+     * Cancel and join in-process invocations, clear transient waits, then close without terminalizing tasks.
+     * The views and the session are closed even when joining or the waiting-state commit fails (a storage
+     * that refuses writes), so a failed suspend never leaks the session files; the first error is rethrown.
+     */
     async suspend(ctx) {
         if (this.suspended)
             return;
         this.suspended = true;
-        await this.scheduler.joinAll();
-        const tools = [...this.session.liveTasks.values()].filter((task) => task.kind === "pi.tool");
-        if (tools.length > 0) {
-            const docs = [...new Set(tools.map((task) => task.conversationId))].map((conversationId) => ({ doc: "sticky", conversationId }));
-            await this.session.commit(KERNEL, (tx) => {
-                for (const task of tools) {
-                    const index = task.input.index;
-                    const slot = tx.sticky(task.conversationId).turn.tools[index];
-                    if (slot?.waitingOn !== undefined)
-                        delete slot.waitingOn;
-                }
-            }, ctx, { docs });
+        let failure;
+        try {
+            await this.scheduler.joinAll();
+            const tools = [...this.session.liveTasks.values()].filter((task) => task.kind === "pi.tool");
+            if (tools.length > 0) {
+                const docs = [...new Set(tools.map((task) => task.conversationId))].map((conversationId) => ({ doc: "sticky", conversationId }));
+                await this.session.commit(KERNEL, (tx) => {
+                    for (const task of tools) {
+                        const index = task.input.index;
+                        const slot = tx.sticky(task.conversationId).turn.tools[index];
+                        if (slot?.waitingOn !== undefined)
+                            delete slot.waitingOn;
+                    }
+                }, ctx, { docs });
+            }
+        }
+        catch (error) {
+            failure = { error };
         }
         this.views.close();
-        await this.session.close(ctx);
+        try {
+            await this.session.close(ctx);
+        }
+        catch (error) {
+            failure ??= { error };
+        }
+        if (failure !== undefined)
+            throw failure.error;
     }
     // --- registries --------------------------------------------------------------
     registerTaskKind(kind) {

package/dist/index.d.ts

@@ -26,6 +26,7 @@ export * from "./harness/utils/segmented-read-view.ts";
 export * from "./harness/utils/shell-output.ts";
 export * from "./harness/utils/truncate.ts";
 export * from "./proxy.ts";
+export * from "./response-timing.ts";
 export * from "./search/index.ts";
 export { setDefaultStreamFn } from "./stream-fn.ts";
 export { prepareToolArguments } from "./tool-arguments.ts";

package/dist/index.js

@@ -24,6 +24,7 @@ export * from "./harness/utils/segmented-read-view.js";
 export * from "./harness/utils/shell-output.js";
 export * from "./harness/utils/truncate.js";
 export * from "./proxy.js";
+export * from "./response-timing.js";
 export * from "./search/index.js";
 export { setDefaultStreamFn } from "./stream-fn.js";
 export { prepareToolArguments } from "./tool-arguments.js";

package/dist/response-timing.d.ts

@@ -0,0 +1,31 @@
+import type { AssistantMessage, AssistantMessageEvent } from "@earendil-works/pi-ai";
+/** The deltas that count as streamed output for time to first token and the generation window. */
+export declare const STREAMED_DELTA_TYPES: ReadonlySet<string>;
+export type GenerationWindowMessage = {
+    readonly usage?: {
+        readonly reasoning?: number;
+    };
+    readonly content?: ReadonlyArray<{
+        readonly type?: string;
+    }>;
+};
+/**
+ * Whether a response generated output before its first streamed delta, so its generation window starts at the
+ * response start instead (senpi#3393). Reasoning counted in usage.output may be hidden or only summarised after it
+ * finished; a thinking block whose text never streamed (Bedrock, omitted display) reports no reasoning count. Shared
+ * by the persisted timing (senpi#3879) and the TPS notice so both measure the same window.
+ */
+export declare function reasonedBeforeFirstDelta(message: GenerationWindowMessage, thinkingStreamed: boolean): boolean;
+/**
+ * Records one response's timing as the agent loop streams it, then stamps it on the final message (senpi#3879).
+ * Wall-clock fields use `Date.now()` so they line up with `timestamp`; the generation window uses the monotonic
+ * clock, like the TPS notice, so a clock jump cannot make it negative.
+ */
+export declare function createResponseTimingRecorder(): {
+    requested(): void;
+    started(): void;
+    observe(event: AssistantMessageEvent): void;
+    /** Stamps the final message. A response whose request was never issued gets no timing. */
+    stamp(message: AssistantMessage): void;
+};
+//# sourceMappingURL=response-timing.d.ts.map

package/dist/response-timing.js

@@ -0,0 +1,66 @@
+/** The deltas that count as streamed output for time to first token and the generation window. */
+export const STREAMED_DELTA_TYPES = new Set(["text_delta", "thinking_delta", "toolcall_delta"]);
+/**
+ * Whether a response generated output before its first streamed delta, so its generation window starts at the
+ * response start instead (senpi#3393). Reasoning counted in usage.output may be hidden or only summarised after it
+ * finished; a thinking block whose text never streamed (Bedrock, omitted display) reports no reasoning count. Shared
+ * by the persisted timing (senpi#3879) and the TPS notice so both measure the same window.
+ */
+export function reasonedBeforeFirstDelta(message, thinkingStreamed) {
+    if ((message.usage?.reasoning ?? 0) > 0)
+        return true;
+    if (thinkingStreamed)
+        return false;
+    return message.content?.some((block) => block.type === "thinking") ?? false;
+}
+/**
+ * Records one response's timing as the agent loop streams it, then stamps it on the final message (senpi#3879).
+ * Wall-clock fields use `Date.now()` so they line up with `timestamp`; the generation window uses the monotonic
+ * clock, like the TPS notice, so a clock jump cannot make it negative.
+ */
+export function createResponseTimingRecorder() {
+    let requestedAt;
+    let startedMs;
+    let firstDeltaMs;
+    let lastDeltaMs;
+    let firstTokenAt;
+    let lastTokenAt;
+    let thinkingStreamed = false;
+    return {
+        requested() {
+            requestedAt = Date.now();
+        },
+        started() {
+            startedMs ??= performance.now();
+        },
+        observe(event) {
+            if (!STREAMED_DELTA_TYPES.has(event.type))
+                return;
+            const now = performance.now();
+            const at = Date.now();
+            if (event.type === "thinking_delta")
+                thinkingStreamed = true;
+            firstDeltaMs ??= now;
+            firstTokenAt ??= at;
+            lastDeltaMs = now;
+            lastTokenAt = at;
+        },
+        /** Stamps the final message. A response whose request was never issued gets no timing. */
+        stamp(message) {
+            if (requestedAt === undefined)
+                return;
+            const windowStart = reasonedBeforeFirstDelta(message, thinkingStreamed) ? startedMs : firstDeltaMs;
+            const generationMs = windowStart !== undefined && lastDeltaMs !== undefined && lastDeltaMs > windowStart
+                ? Math.round(lastDeltaMs - windowStart)
+                : undefined;
+            message.timing = {
+                requestedAt,
+                ...(firstTokenAt === undefined ? {} : { firstTokenAt }),
+                ...(lastTokenAt === undefined ? {} : { lastTokenAt }),
+                endedAt: Math.max(Date.now(), lastTokenAt ?? requestedAt),
+                ...(generationMs === undefined ? {} : { generationMs }),
+            };
+        },
+    };
+}
+//# sourceMappingURL=response-timing.js.map

package/package.json

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