jeopi-agent-core 16.4.2 → 16.4.3

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [16.4.3] - 2026-07-22
+
+### Fixed
+
+- Fixed skipped sibling tool results caused by system advisor steering so they no longer claim a queued user message caused the skip. `hasSteeringMessages` may now return a `SteeringQueueState` (`{ queued, source }`) instead of a plain boolean; the skipped-tool-result wording distinguishes queued user messages, pending system advisories, and peer IRC interrupts. Ported from oh-my-pi (upstream `74c63fa6c`).
+
 ## [16.2.30] - 2026-07-10
 
 ### Fixed

package/dist/types/types.d.ts

@@ -53,6 +53,15 @@ export interface SoftToolRequirement {
 export type ToolChoiceDirective = ToolChoice | SoftToolRequirement;
 /** True when a {@link ToolChoiceDirective} is a soft requirement, not a hard choice. */
 export declare function isSoftToolRequirement(directive: ToolChoiceDirective | undefined): directive is SoftToolRequirement;
+/** Source category for a queued steering interrupt observed without consuming the queue. */
+export type SteeringInterruptSource = "user" | "system" | "unknown";
+/** Non-consuming summary of whether queued steering should interrupt a tool batch. */
+export interface SteeringQueueState {
+    /** True when at least one steering message is queued. */
+    queued: boolean;
+    /** Best-effort origin used only to word synthetic skipped-tool results. */
+    source?: SteeringInterruptSource;
+}
 /**
  * Configuration for the agent loop.
  */
@@ -156,8 +165,12 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      *
      * When omitted, steering never interrupts a running tool batch; queued
      * messages are still delivered at the next injection boundary.
+     *
+     * Returning `true` is treated as user-originated steering for compatibility.
+     * Return a {@link SteeringQueueState} when the queue can distinguish system
+     * advisories from real user messages.
      */
-    hasSteeringMessages?: () => boolean | Promise<boolean>;
+    hasSteeringMessages?: () => boolean | SteeringQueueState | Promise<boolean | SteeringQueueState>;
     /**
      * Peeks whether IRC messages should interrupt an interruptible waiting tool.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-agent-core",
-	"version": "16.4.2",
+	"version": "16.4.3",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -35,12 +35,12 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"jeopi-ai": "16.4.2",
-		"jeopi-catalog": "16.4.2",
-		"jeopi-natives": "16.4.2",
-		"jeopi-utils": "16.4.2",
-		"jeopi-wire": "16.4.2",
-		"jeopi-snapcompact": "16.4.2",
+		"jeopi-ai": "16.4.3",
+		"jeopi-catalog": "16.4.3",
+		"jeopi-natives": "16.4.3",
+		"jeopi-utils": "16.4.3",
+		"jeopi-wire": "16.4.3",
+		"jeopi-snapcompact": "16.4.3",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {

package/src/agent-loop.ts

@@ -66,6 +66,8 @@ import type {
 	AgentToolResult,
 	AgentTurnEndContext,
 	AsideMessage,
+	SteeringInterruptSource,
+	SteeringQueueState,
 	StreamFn,
 } from "./types";
 import { isSoftToolRequirement } from "./types";
@@ -1723,7 +1725,7 @@ async function executeToolCalls(
 	const interruptibleSignal: AbortSignal = signal
 		? AbortSignal.any([signal, steeringAbortController.signal, ircAbortController.signal])
 		: AbortSignal.any([steeringAbortController.signal, ircAbortController.signal]);
-	const interruptState = { triggered: false };
+	const interruptState: { triggered: boolean; source?: SteeringInterruptSource | "irc" } = { triggered: false };
 
 	const records = toolCalls.map(toolCall => {
 		// Tools emitted via OpenAI's custom-tool path (e.g. `apply_patch` on GPT-5)
@@ -1758,17 +1760,28 @@ async function executeToolCalls(
 		// the injection boundary. Fall back to consuming steering only for older
 		// integrations that never supplied a peek.
 		let steeringQueued = false;
+		let steeringSource: SteeringInterruptSource | undefined;
 		if (hasSteeringMessages) {
-			steeringQueued = await hasSteeringMessages();
+			const queuedState = await hasSteeringMessages();
+			if (typeof queuedState === "boolean") {
+				steeringQueued = queuedState;
+				steeringSource = queuedState ? "user" : undefined;
+			} else {
+				const state: SteeringQueueState = queuedState;
+				steeringQueued = state.queued;
+				steeringSource = state.source ?? (state.queued ? "unknown" : undefined);
+			}
 		} else if (getSteeringMessages) {
 			const msgs = await getSteeringMessages();
 			steeringQueued = (msgs?.length ?? 0) > 0;
+			steeringSource = steeringQueued ? "user" : undefined;
 		}
 		if (steeringQueued) {
-			// User steering upgrades an in-flight IRC interrupt: it aborts the
+			// Queued steering upgrades an in-flight IRC interrupt: it aborts the
 			// shared signal so foreground tools stop as they do for a user Esc.
 			if (!steeringAbortController.signal.aborted) {
 				interruptState.triggered = true;
+				interruptState.source = steeringSource ?? "unknown";
 				steeringAbortController.abort();
 			}
 			return;
@@ -1778,6 +1791,7 @@ async function executeToolCalls(
 			// Peer IRC only aborts interruptible waits: a foreground bash / write
 			// mid-execution keeps running so we never leave partial side effects.
 			interruptState.triggered = true;
+			interruptState.source = "irc";
 			ircAbortController.abort();
 		}
 	};
@@ -2038,7 +2052,7 @@ async function executeToolCalls(
 			// This tool's own signal fired AND it failed — it was cut off before producing
 			// a usable result, so report it as skipped.
 			record.skipped = true;
-			emitToolResult(record, createSkippedToolResult(), true);
+			emitToolResult(record, createSkippedToolResult(interruptState.source), true);
 		} else {
 			// No interrupt on this signal, or the tool finished (successfully or with a
 			// genuine error) before the interrupt landed. Keep its real result: a completed
@@ -2132,7 +2146,7 @@ async function executeToolCalls(
 				toolName: record.toolCall.name,
 				status: "skipped",
 			});
-			emitToolResult(record, createSkippedToolResult(), true);
+			emitToolResult(record, createSkippedToolResult(interruptState.source), true);
 		}
 	}
 
@@ -2201,12 +2215,24 @@ function createToolSignalAbortedResult(signal: AbortSignal): AgentToolResult<unk
 	};
 }
 
-function createSkippedToolResult(): AgentToolResult<any> {
+function createSkippedToolResult(source: SteeringInterruptSource | "irc" | undefined): AgentToolResult<any> {
+	let reason = "pending steering message";
+	let blocker = "queued message";
+	if (source === "user") {
+		reason = "queued user message";
+		blocker = "queued message";
+	} else if (source === "system") {
+		reason = "pending system advisory";
+		blocker = "advisory";
+	} else if (source === "irc") {
+		reason = "pending peer interrupt";
+		blocker = "interrupt";
+	}
 	return {
 		content: [
 			{
 				type: "text",
-				text: "Skipped due to queued user message. Do not count this skipped result as completed work or verification. After the queued message is handled on the next step, retry the skipped tool if it is still needed.",
+				text: `Skipped due to ${reason}. Do not count this skipped result as completed work or verification. After the ${blocker} is handled on the next step, retry the skipped tool if it is still needed.`,
 			},
 		],
 		details: {},

package/src/agent.ts

@@ -1185,7 +1185,19 @@ export class Agent {
 				}
 				return this.#dequeueSteeringMessages();
 			},
-			hasSteeringMessages: () => this.#steeringQueue.length > 0,
+			hasSteeringMessages: () => {
+				if (this.#steeringQueue.length === 0) {
+					return { queued: false };
+				}
+				for (const message of this.#steeringQueue) {
+					const role = "role" in message ? message.role : undefined;
+					const attribution = "attribution" in message ? message.attribution : undefined;
+					if (role === "user" && attribution !== "agent") {
+						return { queued: true, source: "user" };
+					}
+				}
+				return { queued: true, source: "system" };
+			},
 			hasIrcInterrupts: this.hasIrcInterrupts,
 			getFollowUpMessages: async () => this.#dequeueFollowUpMessages(),
 			getAsideMessages: async () => (await this.#asideMessageProvider?.()) ?? [],

package/src/types.ts

@@ -83,6 +83,17 @@ export function isSoftToolRequirement(directive: ToolChoiceDirective | undefined
 	return typeof directive === "object" && directive !== null && (directive as SoftToolRequirement).soft === true;
 }
 
+/** Source category for a queued steering interrupt observed without consuming the queue. */
+export type SteeringInterruptSource = "user" | "system" | "unknown";
+
+/** Non-consuming summary of whether queued steering should interrupt a tool batch. */
+export interface SteeringQueueState {
+	/** True when at least one steering message is queued. */
+	queued: boolean;
+	/** Best-effort origin used only to word synthetic skipped-tool results. */
+	source?: SteeringInterruptSource;
+}
+
 /**
  * Configuration for the agent loop.
  */
@@ -196,8 +207,12 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	 *
 	 * When omitted, steering never interrupts a running tool batch; queued
 	 * messages are still delivered at the next injection boundary.
+	 *
+	 * Returning `true` is treated as user-originated steering for compatibility.
+	 * Return a {@link SteeringQueueState} when the queue can distinguish system
+	 * advisories from real user messages.
 	 */
-	hasSteeringMessages?: () => boolean | Promise<boolean>;
+	hasSteeringMessages?: () => boolean | SteeringQueueState | Promise<boolean | SteeringQueueState>;
 
 	/**
 	 * Peeks whether IRC messages should interrupt an interruptible waiting tool.