@skydiveai/pi-extensions 0.1.252-beta.5 → 0.1.252-beta.6

package/dist/index.mjs

@@ -3028,6 +3028,13 @@ const bashDefaultTimeoutExtension = (pi) => {
 * idle sandbox's resource usage is not the agent's problem and there is no
 * open turn to deliver into anyway.
 *
+* Delivery is further gated to turns that are ACTIVELY in tool-call work
+* (see WarningDeliveryGate): a warning that lands once the model has moved
+* on to its final reply triggers a continuation turn after the answer was
+* already produced, which breaks external-channel delivery (Slack steer-
+* after-reply). So the warning only interrupts between/around tool calls
+* and never chases a turn that is already wrapping up.
+*
 * Best-effort throughout: any read failure (cgroup absent, controller not
 * delegated, non-cgroup-v2 host, df missing) reads as "no signal" for that
 * stat and the extension warns on what it can see — it must never break a
@@ -3151,20 +3158,77 @@ function resourcePressureWarningText(trigger, { mem, cpuPct, diskPct }) {
 	const closer = trigger === "memory" ? "If the workload genuinely needs more memory or CPU, request a bigger sandbox with `platform compute request`." : "A bigger compute tier will not add disk. Free space on the current computer instead, and do not request a compute upgrade for disk pressure.";
 	return `<system_notification>${lead} Current usage: ${stats.join(", ")}. Act now: ${remedy} ${closer} Do not mention this constraint as you work unless the user asks. This warning does not change whether the user is owed a reply. Do not call \`platform channel suppress-reply\` because of this warning. Complete any reply already owed after checkpointing. This is an automated resource warning, not a message from the user; continue the task, adjusted.</system_notification>`;
 }
+/**
+* Whether a pressure warning may be delivered into the open turn right now.
+*
+* Only interrupts turns that are actively in tool-call work. The failure it
+* guards against: the poll lands after the model has stopped calling tools
+* and is streaming (or has finished) its final reply. `sendMessage` with
+* `triggerTurn: true` then starts a continuation turn BEHIND an answer the
+* user is already owed, which wedges external-channel delivery (Slack).
+*
+* Deliverable means ALL of:
+* - agent active (between agent_start and agent_end),
+* - the turn has issued at least one tool call,
+* - no assistant message is currently streaming (while one streams we cannot
+*   know whether it will end the loop, so we hold and re-poll),
+* - the loop is not closed: no assistant message without tool calls has
+*   completed this turn (that message IS the final reply; anything after it
+*   is post-answer and must not be steered).
+*
+* Pure and exported so the gating is regression-testable without fake timers.
+*/
+var WarningDeliveryGate = class {
+	agentActive = false;
+	sawToolCall = false;
+	toolsInFlight = 0;
+	messageStreaming = false;
+	loopClosed = false;
+	agentStart() {
+		this.agentActive = true;
+		this.sawToolCall = false;
+		this.toolsInFlight = 0;
+		this.messageStreaming = false;
+		this.loopClosed = false;
+	}
+	agentEnd() {
+		this.agentActive = false;
+		this.messageStreaming = false;
+	}
+	toolExecutionStart() {
+		this.sawToolCall = true;
+		this.toolsInFlight += 1;
+	}
+	toolExecutionEnd() {
+		this.toolsInFlight = Math.max(0, this.toolsInFlight - 1);
+	}
+	messageStart(message) {
+		if (message.role !== "assistant") return;
+		this.messageStreaming = true;
+	}
+	messageEnd(message) {
+		if (message.role !== "assistant") return;
+		this.messageStreaming = false;
+		if (!(Array.isArray(message.content) && message.content.some((part) => part.type === "toolCall"))) this.loopClosed = true;
+	}
+	canDeliver() {
+		return this.agentActive && this.sawToolCall && !this.loopClosed && !this.messageStreaming;
+	}
+};
 const resourcePressureWarningExtension = (pi) => {
-	let agentActive = false;
+	const gate = new WarningDeliveryGate();
 	let warnedMemThisTurn = false;
 	let warnedDiskThisTurn = false;
 	let timer = null;
 	const sampleCpu = createCpuSampler();
 	async function checkOnce() {
-		if (!agentActive || warnedMemThisTurn && warnedDiskThisTurn) return;
+		if (!gate.canDeliver() || warnedMemThisTurn && warnedDiskThisTurn) return;
 		const [mem, cpuPct, diskPct] = await Promise.all([
 			readMemUsePct(),
 			sampleCpu(),
 			readDiskUsePct()
 		]);
-		if (!agentActive) return;
+		if (!gate.canDeliver()) return;
 		let trigger = null;
 		if (!warnedMemThisTurn && mem !== null && mem.pct >= 80) {
 			trigger = "memory";
@@ -3193,8 +3257,20 @@ const resourcePressureWarningExtension = (pi) => {
 			deliverAs: "followUp"
 		});
 	}
+	pi.on("tool_execution_start", () => {
+		gate.toolExecutionStart();
+	});
+	pi.on("tool_execution_end", () => {
+		gate.toolExecutionEnd();
+	});
+	pi.on("message_start", (event) => {
+		gate.messageStart(event.message);
+	});
+	pi.on("message_end", (event) => {
+		gate.messageEnd(event.message);
+	});
 	pi.on("agent_start", async () => {
-		agentActive = true;
+		gate.agentStart();
 		warnedMemThisTurn = false;
 		warnedDiskThisTurn = false;
 		if (!timer) {
@@ -3207,7 +3283,7 @@ const resourcePressureWarningExtension = (pi) => {
 		}
 	});
 	pi.on("agent_end", async () => {
-		agentActive = false;
+		gate.agentEnd();
 		if (timer) {
 			clearInterval(timer);
 			timer = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skydiveai/pi-extensions",
-  "version": "0.1.252-beta.5",
+  "version": "0.1.252-beta.6",
   "homepage": "https://skydive.com",
   "license": "MIT",
   "author": "Create, Inc.",