@fastagent-sh/fastagent 0.24.1 → 0.24.2

package/dist/engines/pi/agent-session-factory.js

@@ -11,6 +11,7 @@ import { resolveModel } from "./config.js";
 import { activePath, resolveSessionSettings } from "./session-settings.js";
 import { DEFAULT_THINKING_LEVEL, withModelRegistration } from "./models.js";
 import { registerAccountModels } from "./openai-account-models.js";
+import { asksToEndRun, markEndsRun } from "./turn-kit.js";
 import { agentSessionManager, sessionToolActivation, turnContext } from "./tool-context.js";
 /** fastagent's tools as pi tool definitions, bound to ONE session. */
 function toolDefinitions(tools, bound, sessionId) {
@@ -161,7 +162,7 @@ const nativeExtensions = BUILTIN_EXTENSIONS.map((name) => ({
 /** The resource posture a fastagent definition asks pi for — ONE definition of it, for both assemblies. */
 export function definitionResourceLoaderOptions(source) {
     return {
-        extensionFactories: [...nativeExtensions, compactAdmission],
+        extensionFactories: [...nativeExtensions, compactAdmission, recordEndsRun],
         // The machine's extensions are its owner's setup, not this agent's.
         noExtensions: true,
         // Explicit paths survive noExtensions, including Pi's built-ins; so they would also survive the machine's own
@@ -193,6 +194,29 @@ export function definitionResourceLoaderOptions(source) {
         promptsOverride: () => ({ prompts: [...source.machine.prompts], diagnostics: [] }),
     };
 }
+/**
+ * Records on a tool result that it asked to end its run ({@link asksToEndRun}), so `entries()` can tell a run that
+ * ended on its tool batch from one cut after its tools. Through pi's `message_end` replacement, which runs before pi
+ * appends the message to the record. LAST among the extensions (pi appends inline factories after path ones), so a
+ * definition's own `message_end` replacement cannot drop the flag. One instance per loader, so per session.
+ */
+const recordEndsRun = {
+    name: "fastagent-record-ends-run",
+    hidden: true,
+    factory: (pi) => {
+        const asked = new Set();
+        pi.on("tool_execution_end", (event) => {
+            if (asksToEndRun(event))
+                asked.add(event.toolCallId);
+        });
+        pi.on("message_end", (event) => {
+            const message = event.message;
+            if (message.role !== "toolResult" || !asked.delete(message.toolCallId))
+                return;
+            return { message: markEndsRun(message) };
+        });
+    },
+};
 /** Manual compactions waiting for pi's admission, keyed by the session's record (what an extension's `ctx` names). */
 const compactAdmissions = new WeakMap();
 const COMPACT_ADMISSION = "fastagent-compact-admission";

package/dist/engines/pi/invoke-session.js

@@ -10,7 +10,7 @@ import { log } from "../../log.js";
 import { toRetryScheduledEvent } from "./retry-event.js";
 import { PortFailure, port, portAbort, portCleanup, portError } from "../../effect-port.js";
 import { SessionBusy, acquireSession, acquireSessionLease } from "./session-effects.js";
-import { errorToTerminal, inProcessLease, agentEventProjection, answerOutcome, toPiPromptOptions, toTerminal, } from "./turn-kit.js";
+import { errorToTerminal, inProcessLease, agentEventProjection, answerOutcome, asksToEndRun, toPiPromptOptions, toTerminal, } from "./turn-kit.js";
 // Structured output is for scripts. Observation publishes Pi's display result, including bounded nested traces.
 function displayToolResult(result) {
     const { structuredContent: _internal, ...display } = result;
@@ -78,6 +78,7 @@ function toSessionEvent(event, runId) {
                     isError: event.isError,
                     content: displayToolResult(event.result),
                     ...(event.parentToolCallId ? { parentToolCallId: event.parentToolCallId } : {}),
+                    ...(asksToEndRun(event) ? { terminate: true } : {}),
                 },
             };
         case "queue_update":

package/dist/engines/pi/session-control.js

@@ -12,7 +12,7 @@ import { SESSION_BUSY_CODE } from "../../agent.js";
 import { BOUNDARY_COMMAND_FAILED_CODE, INVALID_COMMAND_CODE, isAddressableSession, NO_ACTIVE_RUN_CODE, NOTHING_TO_COMPACT_CODE, NO_SUCH_SESSION_CODE, PARTIAL_UPDATE_CODE, UPDATE_FIELDS, RUN_COMMAND_FAILED_CODE, UNSUPPORTED_CAPABILITY_CODE, } from "../../session.js";
 import { forkProvenance, isConversationMessage, isNavigable, publishedLeaf } from "./session-markers.js";
 import { entryImages, imageAt } from "./entry-images.js";
-import { answerOutcome } from "./turn-kit.js";
+import { answerOutcome, endsRun } from "./turn-kit.js";
 import { startCompaction } from "./agent-session-factory.js";
 import { toRetryScheduledEvent } from "./retry-event.js";
 import { THINKING_LEVELS, activePath, describeModels, resolveSessionSettings } from "./session-settings.js";
@@ -107,6 +107,8 @@ function toSessionEntry(entry, parentId) {
                     isError: m.isError ?? false,
                     text: contentText(m.content, ""),
                     ...entryImages(entry.id, m),
+                    // Same flag as the live `tool_finished` (turn-kit.ts asksToEndRun).
+                    ...(endsRun(m) ? { terminate: true } : {}),
                 },
             };
         }

package/dist/engines/pi/turn-kit.d.ts

@@ -1,4 +1,4 @@
-import { type AssistantMessage, type ImageContent } from "@earendil-works/pi-ai";
+import { type AssistantMessage, type ImageContent, type ToolResultMessage } from "@earendil-works/pi-ai";
 import { type AgentEvent, type Prompt } from "../../agent.ts";
 import type { AnswerOutcome, PromptDisposition, SessionEvent } from "../../session.ts";
 export type Release = () => void;
@@ -18,6 +18,25 @@ export declare function classifyRetryable(details: string, signal: {
  * the recorded one cannot disagree.
  */
 export declare function answerOutcome(message: AssistantMessage): AnswerOutcome | undefined;
+/**
+ * Whether a finished tool call asked to end its run (pi's `terminate`: returned by the tool, or set by a `tool_call`
+ * hook that blocks it; pi 0.99.2's `tool_result` hook cannot set it). After a batch whose EVERY result asks it, pi
+ * makes no further model call for that batch, so unless a queued steer or follow-up continues the run, it completes on
+ * `tool` entries with no answer after them: the same shape a process killed after its tools leaves. A call made from
+ * inside another tool (`parentToolCallId`, a codemode script) is not in the batch and does not count.
+ * The ONE reading: the live `tool_finished` and the flag {@link markEndsRun} records both come from it.
+ */
+export declare function asksToEndRun(event: {
+    result?: unknown;
+    parentToolCallId?: string;
+}): boolean;
+/**
+ * The tool result message as pi then records it, carrying the request: pi's `createToolResultMessage` drops
+ * `terminate` (as of pi 0.99.2), so without this nothing in the record says the run ended on purpose.
+ */
+export declare function markEndsRun(message: ToolResultMessage): ToolResultMessage;
+/** Whether a recorded tool result carries {@link markEndsRun}'s flag. */
+export declare function endsRun(message: ToolResultMessage): boolean;
 /**
  * Terminal mapping, decided by the resolved message's outcome: pi's `prompt()` RESOLVES a message with stopReason
  * "error"/"aborted" rather than throwing, so relying on catch alone would miss that whole failure class and violate

package/dist/engines/pi/turn-kit.js

@@ -91,6 +91,28 @@ export function answerOutcome(message) {
             return undefined;
     }
 }
+/**
+ * Whether a finished tool call asked to end its run (pi's `terminate`: returned by the tool, or set by a `tool_call`
+ * hook that blocks it; pi 0.99.2's `tool_result` hook cannot set it). After a batch whose EVERY result asks it, pi
+ * makes no further model call for that batch, so unless a queued steer or follow-up continues the run, it completes on
+ * `tool` entries with no answer after them: the same shape a process killed after its tools leaves. A call made from
+ * inside another tool (`parentToolCallId`, a codemode script) is not in the batch and does not count.
+ * The ONE reading: the live `tool_finished` and the flag {@link markEndsRun} records both come from it.
+ */
+export function asksToEndRun(event) {
+    return !event.parentToolCallId && event.result?.terminate === true;
+}
+/**
+ * The tool result message as pi then records it, carrying the request: pi's `createToolResultMessage` drops
+ * `terminate` (as of pi 0.99.2), so without this nothing in the record says the run ended on purpose.
+ */
+export function markEndsRun(message) {
+    return { ...message, terminate: true };
+}
+/** Whether a recorded tool result carries {@link markEndsRun}'s flag. */
+export function endsRun(message) {
+    return message.terminate === true;
+}
 /**
  * Terminal mapping, decided by the resolved message's outcome: pi's `prompt()` RESOLVES a message with stopReason
  * "error"/"aborted" rather than throwing, so relying on catch alone would miss that whole failure class and violate

package/dist/session.d.ts

@@ -388,11 +388,17 @@ export type ToolProgressEvent = SessionEvent<"tool_progress", {
 }> & {
     runId: string;
 };
+/**
+ * `terminate: true` when the call asked to end its run. Once every call answering one assistant message asks it, the
+ * model is not called again for them, and the run ends there with no answer after its `tool` entries (which carry the
+ * same flag) unless a queued steer or follow-up continues it. Whether the run ended is `run_settled`'s to say.
+ */
 export type ToolFinishedEvent = SessionEvent<"tool_finished", {
     id: string;
     isError: boolean;
     content: Json;
     parentToolCallId?: string;
+    terminate?: true;
 }> & {
     runId: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.24.1",
+  "version": "0.24.2",
   "description": "Vibe first. Then FastAgent: turn a local agent directory into a live service in your app, on Telegram, Slack, Feishu, or behind any channel.",
   "keywords": [
     "agent",