@fastagent-sh/fastagent 0.24.3 → 0.24.4

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

@@ -11,7 +11,7 @@ import { resolveModel } from "./config.js";
 import { MissingModel, 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 { abortedAnswer, asksToEndRun, markEndsRun } from "./turn-kit.js";
 import { agentSessionManager, sessionToolActivation, turnContext } from "./tool-context.js";
 /**
  * What pi's own coding tools say about themselves in its default prompt. The coding tools fastagent mounts are pi's
@@ -217,6 +217,7 @@ export function definitionResourceLoaderOptions(source) {
             ...nativeExtensions,
             compactAdmission,
             recordEndsRun,
+            recordAbortedAnswers,
             ...(definition.sections && Object.keys(definition.sections).length > 0
                 ? [fastagentSections(definition.sections)]
                 : []),
@@ -279,6 +280,23 @@ const recordEndsRun = {
         });
     },
 };
+/**
+ * Records an answer that failed because its run was stopped as aborted ({@link abortedAnswer}), through pi's
+ * `message_end` replacement, which runs before pi appends the message to the record and before the plane's own
+ * listener sees it. `ctx.signal` is the run's own abort signal, the one pi's readings use.
+ */
+const recordAbortedAnswers = {
+    name: "fastagent-record-aborted-answers",
+    hidden: true,
+    factory: (pi) => {
+        pi.on("message_end", (event, ctx) => {
+            if (event.message.role !== "assistant")
+                return;
+            const aborted = abortedAnswer(event.message, ctx.signal);
+            return aborted ? { message: aborted } : undefined;
+        });
+    },
+};
 /** 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/turn-kit.d.ts

@@ -18,6 +18,15 @@ export declare function classifyRetryable(details: string, signal: {
  * the recorded one cannot disagree.
  */
 export declare function answerOutcome(message: AssistantMessage): AnswerOutcome | undefined;
+/**
+ * An answer that failed while its run's abort was in effect, as what it was: aborted. Undefined when that is not the
+ * case (no abort, or not a failure). pi's own reading is `signal.aborted ? "aborted" : "error"` (`handleRunFailure`,
+ * the providers), but its request-setup path (`lazyStream`: auth, request preparation) writes "error" whatever the
+ * signal (pi 0.99.2). A run stopped during a tool lands there: the loop asks the model once more, and the setup throws
+ * the abort. Recorded this way, the answer's {@link answerOutcome} is the `aborted` the run settled with, live and read
+ * back. A failure recorded BEFORE the abort (a provider error whose retry was then stopped) stays as recorded.
+ */
+export declare function abortedAnswer(message: AssistantMessage, runSignal: AbortSignal | undefined): AssistantMessage | undefined;
 /**
  * An answer's recorded thinking: its published thinking blocks, in order, joined with nothing between them, exactly as
  * their live deltas add up (the stream marks no block boundary, and the answer's `text` is joined the same way).

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

@@ -91,6 +91,19 @@ export function answerOutcome(message) {
             return undefined;
     }
 }
+/**
+ * An answer that failed while its run's abort was in effect, as what it was: aborted. Undefined when that is not the
+ * case (no abort, or not a failure). pi's own reading is `signal.aborted ? "aborted" : "error"` (`handleRunFailure`,
+ * the providers), but its request-setup path (`lazyStream`: auth, request preparation) writes "error" whatever the
+ * signal (pi 0.99.2). A run stopped during a tool lands there: the loop asks the model once more, and the setup throws
+ * the abort. Recorded this way, the answer's {@link answerOutcome} is the `aborted` the run settled with, live and read
+ * back. A failure recorded BEFORE the abort (a provider error whose retry was then stopped) stays as recorded.
+ */
+export function abortedAnswer(message, runSignal) {
+    return message.stopReason === "error" && runSignal?.aborted === true
+        ? { ...message, stopReason: "aborted" }
+        : undefined;
+}
 /**
  * Whether a thinking block is PUBLISHED: readable reasoning. A redacted one holds a provider's opaque payload and a
  * placeholder (pi writes "[Reasoning redacted]" for it), not reasoning anyone can read, so it is neither streamed nor

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.24.3",
+  "version": "0.24.4",
   "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",