@oh-my-pi/pi-agent-core 15.5.6 → 15.5.8

package/dist/types/agent.d.ts

@@ -1,6 +1,3 @@
-/** Agent class that uses the agent-loop directly.
- * No transport abstraction - calls streamSimple via the loop.
- */
 import { type AssistantMessage, type AssistantMessageEvent, type CursorExecHandlers, type CursorToolResultHandler, type Effort, type ImageContent, type Message, type Model, type ProviderSessionState, type ServiceTier, type SimpleStreamOptions, type ThinkingBudgets, type ToolChoice } from "@oh-my-pi/pi-ai";
 import type { AppendOnlyContextManager } from "./append-only-context";
 import type { HarmonyAuditEvent } from "./harmony-leak";

package/dist/types/compaction/compaction.d.ts

@@ -6,6 +6,7 @@
  */
 import { type MessageAttribution, type Model, type Usage } from "@oh-my-pi/pi-ai";
 import { type AgentTelemetry } from "../telemetry";
+import { ThinkingLevel } from "../thinking";
 import type { AgentMessage, AgentTool } from "../types";
 import type { SessionEntry } from "./entries";
 import { type ConvertToLlm } from "./messages";
@@ -115,6 +116,15 @@ export interface SummaryOptions {
      * or `compaction_turn_prefix`). `undefined` keeps the call paths zero-cost.
      */
     telemetry?: AgentTelemetry;
+    /**
+     * Active session thinking level. Threaded from `agent-session.ts` so
+     * compaction honors the user's `/model` thinking selection instead of
+     * silently overriding it with `Effort.High` (the historical default).
+     * `undefined` / `ThinkingLevel.Inherit` falls back to that historical
+     * default; `ThinkingLevel.Off` omits reasoning entirely. See
+     * `resolveCompactionEffort` for the conversion contract.
+     */
+    thinkingLevel?: ThinkingLevel;
 }
 export declare function generateSummary(currentMessages: AgentMessage[], model: Model, reserveTokens: number, apiKey: string, signal?: AbortSignal, customInstructions?: string, previousSummary?: string, options?: SummaryOptions): Promise<string>;
 export interface HandoffOptions {
@@ -131,6 +141,13 @@ export interface HandoffOptions {
      * wrapped in an OTEL chat span tagged with `pi.gen_ai.oneshot.kind = "handoff"`.
      */
     telemetry?: AgentTelemetry;
+    /**
+     * Active session thinking level. Threaded from `agent-session.ts` so
+     * handoff generation honors the user's `/model` thinking selection
+     * instead of silently overriding it with `Effort.High`. See
+     * `resolveCompactionEffort` for the conversion contract.
+     */
+    thinkingLevel?: ThinkingLevel;
 }
 export declare function renderHandoffPrompt(customInstructions?: string): string;
 export declare function generateHandoff(messages: AgentMessage[], model: Model, apiKey: string, options: HandoffOptions, signal?: AbortSignal): Promise<string>;

package/dist/types/utils/yield.d.ts

@@ -24,22 +24,10 @@
  * sleep loops) are retained for the agent-loop hot-path where Promises
  * resolve frequently and the keepalive alone is insufficient.
  */
-/**
- * Await a Promise with an event-loop keepalive active.
- *
- * This is the primary fix for Bun's busy-wait on unresolved Promises.
- * Use it wherever you `await` a Promise that may remain unresolved for
- * an extended period (user input, long-running subprocess, etc.).
- *
- * ```ts
- * // Before (100% CPU while waiting):
- * const input = await mode.getUserInput();
- *
- * // After (proper epoll_wait sleep):
- * const input = await keepaliveWhile(mode.getUserInput());
- * ```
- */
-export declare function keepaliveWhile<T>(promise: Promise<T>): Promise<T>;
+export declare class EventLoopKeepalive {
+    #private;
+    [Symbol.dispose](): void;
+}
 /**
  * Yield to the Bun event loop, sleeping for at least 20 ms — but at most
  * once every {@link YIELD_INTERVAL_MS}. Callers in hot paths can invoke

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "15.5.6",
+	"version": "15.5.8",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -35,9 +35,9 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "15.5.6",
-		"@oh-my-pi/pi-natives": "15.5.6",
-		"@oh-my-pi/pi-utils": "15.5.6",
+		"@oh-my-pi/pi-ai": "15.5.8",
+		"@oh-my-pi/pi-natives": "15.5.8",
+		"@oh-my-pi/pi-utils": "15.5.8",
 		"@opentelemetry/api": "^1.9.0"
 	},
 	"devDependencies": {

package/src/agent.ts

@@ -1,7 +1,6 @@
 /** Agent class that uses the agent-loop directly.
  * No transport abstraction - calls streamSimple via the loop.
  */
-
 import { isPromise } from "node:util/types";
 import {
 	type AssistantMessage,
@@ -36,6 +35,7 @@ import type {
 	StreamFn,
 	ToolCallContext,
 } from "./types";
+import { EventLoopKeepalive } from "./utils/yield";
 
 /**
  * Default convertToLlm: Keep only LLM-compatible messages, convert attachments.
@@ -859,7 +859,7 @@ export class Agent {
 		if (!model) throw new Error("No model configured");
 
 		let skipInitialSteeringPoll = options?.skipInitialSteeringPoll === true;
-
+		using _ = new EventLoopKeepalive();
 		const { promise, resolve } = Promise.withResolvers<void>();
 		this.#runningPrompt = promise;
 		this.#resolveRunningPrompt = resolve;

package/src/compaction/compaction.ts

@@ -7,6 +7,7 @@
 
 import {
 	type AssistantMessage,
+	clampThinkingLevelForModel,
 	Effort,
 	type Message,
 	type MessageAttribution,
@@ -16,6 +17,7 @@ import {
 import { countTokens } from "@oh-my-pi/pi-natives";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import { type AgentTelemetry, instrumentedCompleteSimple } from "../telemetry";
+import { ThinkingLevel } from "../thinking";
 import type { AgentMessage, AgentTool } from "../types";
 import type { CompactionEntry, SessionEntry } from "./entries";
 import { type ConvertToLlm, convertToLlm, createBranchSummaryMessage, createCustomMessage } from "./messages";
@@ -502,6 +504,52 @@ function formatAdditionalContext(context: string[] | undefined): string {
 	return `<additional-context>\n${lines}\n</additional-context>\n\n`;
 }
 
+/**
+ * Maps the non-special `ThinkingLevel` values to their `Effort` counterparts.
+ * Exhaustive over the union; throws for `Off`/`Inherit` to surface logic
+ * errors in callers that forgot to filter those out. Never use a TS cast for
+ * this — `ThinkingLevel` is a string-union over distinct concepts (Off /
+ * Inherit are not Efforts), and a cast hides the contract.
+ */
+function effortFromThinkingLevel(level: ThinkingLevel): Effort {
+	switch (level) {
+		case ThinkingLevel.Minimal:
+			return Effort.Minimal;
+		case ThinkingLevel.Low:
+			return Effort.Low;
+		case ThinkingLevel.Medium:
+			return Effort.Medium;
+		case ThinkingLevel.High:
+			return Effort.High;
+		case ThinkingLevel.XHigh:
+			return Effort.XHigh;
+		case ThinkingLevel.Off:
+		case ThinkingLevel.Inherit:
+			throw new Error(`effortFromThinkingLevel: ${level} must be handled by caller`);
+	}
+}
+
+/**
+ * Resolves the reasoning effort to send on a compaction LLM call.
+ *
+ * - Explicit `Off` → `undefined` (omit reasoning entirely; the user said no thinking).
+ * - `undefined` / `Inherit` → historical `Effort.High` default → clamped per model
+ *   (preserves current behavior for users who never touched the dial).
+ * - Explicit effort → respect user choice → clamped per model.
+ *
+ * The clamp routes through `clampThinkingLevelForModel`, which returns
+ * `undefined` for models with `compat.supportsReasoningEffort: false`
+ * (e.g. `xai-oauth/grok-build`). That `undefined` then flows through to the
+ * openai-responses mapper where `modelOmitsReasoningEffort` short-circuits
+ * the wire param — no `requireSupportedEffort` throw.
+ */
+function resolveCompactionEffort(model: Model, level: ThinkingLevel | undefined): Effort | undefined {
+	if (level === ThinkingLevel.Off) return undefined;
+	const requested: Effort =
+		level === undefined || level === ThinkingLevel.Inherit ? Effort.High : effortFromThinkingLevel(level);
+	return clampThinkingLevelForModel(model, requested);
+}
+
 /**
  * Generate a summary of the conversation using the LLM.
  * If previousSummary is provided, uses the update prompt to merge.
@@ -521,6 +569,15 @@ export interface SummaryOptions {
 	 * or `compaction_turn_prefix`). `undefined` keeps the call paths zero-cost.
 	 */
 	telemetry?: AgentTelemetry;
+	/**
+	 * Active session thinking level. Threaded from `agent-session.ts` so
+	 * compaction honors the user's `/model` thinking selection instead of
+	 * silently overriding it with `Effort.High` (the historical default).
+	 * `undefined` / `ThinkingLevel.Inherit` falls back to that historical
+	 * default; `ThinkingLevel.Off` omits reasoning entirely. See
+	 * `resolveCompactionEffort` for the conversion contract.
+	 */
+	thinkingLevel?: ThinkingLevel;
 }
 
 export async function generateSummary(
@@ -584,7 +641,7 @@ export async function generateSummary(
 			maxTokens,
 			signal,
 			apiKey,
-			reasoning: Effort.High,
+			reasoning: resolveCompactionEffort(model, options?.thinkingLevel),
 			initiatorOverride: options?.initiatorOverride,
 			metadata: options?.metadata,
 		},
@@ -621,6 +678,13 @@ export interface HandoffOptions {
 	 * wrapped in an OTEL chat span tagged with `pi.gen_ai.oneshot.kind = "handoff"`.
 	 */
 	telemetry?: AgentTelemetry;
+	/**
+	 * Active session thinking level. Threaded from `agent-session.ts` so
+	 * handoff generation honors the user's `/model` thinking selection
+	 * instead of silently overriding it with `Effort.High`. See
+	 * `resolveCompactionEffort` for the conversion contract.
+	 */
+	thinkingLevel?: ThinkingLevel;
 }
 
 export function renderHandoffPrompt(customInstructions?: string): string {
@@ -658,7 +722,7 @@ export async function generateHandoff(
 		{
 			apiKey,
 			signal,
-			reasoning: Effort.High,
+			reasoning: resolveCompactionEffort(model, options.thinkingLevel),
 			toolChoice: "none",
 			initiatorOverride: options.initiatorOverride,
 			metadata: options.metadata,
@@ -718,7 +782,7 @@ async function generateShortSummary(
 			maxTokens,
 			signal,
 			apiKey,
-			reasoning: Effort.High,
+			reasoning: resolveCompactionEffort(model, options?.thinkingLevel),
 			initiatorOverride: options?.initiatorOverride,
 			metadata: options?.metadata,
 		},
@@ -905,6 +969,12 @@ export async function compact(
 		metadata: options?.metadata,
 		convertToLlm: options?.convertToLlm,
 		telemetry: options?.telemetry,
+		// Honor /model thinking selection on every fan-out summarizer.
+		// Without this propagation, generateSummary / generateTurnPrefixSummary
+		// see options?.thinkingLevel === undefined and resolveCompactionEffort
+		// silently falls back to Effort.High — the same defect e07b47ee4 fixed
+		// at the call sites, leaked back in here. See resolveCompactionEffort.
+		thinkingLevel: options?.thinkingLevel,
 	};
 
 	let preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined);
@@ -995,6 +1065,9 @@ export async function compact(
 			initiatorOverride: summaryOptions.initiatorOverride,
 			metadata: summaryOptions.metadata,
 			telemetry: summaryOptions.telemetry,
+			// Same propagation as summaryOptions above — generateShortSummary
+			// resolves its own reasoning via resolveCompactionEffort.
+			thinkingLevel: options?.thinkingLevel,
 		},
 	);
 
@@ -1047,7 +1120,7 @@ async function generateTurnPrefixSummary(
 			maxTokens,
 			signal,
 			apiKey,
-			reasoning: Effort.High,
+			reasoning: resolveCompactionEffort(model, options?.thinkingLevel),
 			initiatorOverride: options?.initiatorOverride,
 			metadata: options?.metadata,
 		},

package/src/utils/yield.ts

@@ -31,30 +31,10 @@ import { scheduler } from "node:timers/promises";
 // EventLoopKeepalive — the primary fix for idle-state busy-wait
 // ---------------------------------------------------------------------------
 
-const KEEPALIVE_INTERVAL_MS = 86_400_000; // 24 hours — re-armed each interval
-
-/**
- * Await a Promise with an event-loop keepalive active.
- *
- * This is the primary fix for Bun's busy-wait on unresolved Promises.
- * Use it wherever you `await` a Promise that may remain unresolved for
- * an extended period (user input, long-running subprocess, etc.).
- *
- * ```ts
- * // Before (100% CPU while waiting):
- * const input = await mode.getUserInput();
- *
- * // After (proper epoll_wait sleep):
- * const input = await keepaliveWhile(mode.getUserInput());
- * ```
- */
-export async function keepaliveWhile<T>(promise: Promise<T>): Promise<T> {
-	const ka = setInterval(() => {}, KEEPALIVE_INTERVAL_MS);
-	try {
-		ka.unref();
-		return await promise;
-	} finally {
-		clearInterval(ka);
+export class EventLoopKeepalive {
+	#tmr = setInterval(() => {}, 86_400_000).unref();
+	[Symbol.dispose](): void {
+		clearInterval(this.#tmr);
 	}
 }