@netnodeag/kraftwerk 0.50.0 → 0.50.1

package/dist/inspector/chat/acp.js

@@ -476,7 +476,13 @@ export async function startAcpBackend(agent, cwd, hooks, tuning = {}) {
                     _meta: fileChangeReportMeta(randomUUID()),
                 });
                 turns++;
-                return res.stopReason;
+                // A provider condition that ends the turn itself (usage limit, rate
+                // limit, provider error) is not a notification: the adapter settles
+                // the prompt with stopReason "end_turn" and the typed failure in the
+                // response `_meta`. Without reading it here the turn would end
+                // silently — no text, no error (see failureOf).
+                const failure = failureOf(res._meta);
+                return failure ? { stopReason: res.stopReason, failure } : { stopReason: res.stopReason };
             }
             catch (err) {
                 // A resumed session that cannot even take its first prompt (the

package/dist/inspector/chat/backend.d.ts

@@ -1,4 +1,4 @@
-import type { AgentCommand, Attachment, ChatEvent, ConfigOption, ElicitationAnswer, ElicitationField } from "./types.js";
+import type { AgentCommand, Attachment, ChatEvent, ConfigOption, ElicitationAnswer, ElicitationField, SessionFailure } from "./types.js";
 /** An attachment as the backend gets it: where the file is, and what it is. */
 export interface PromptFile extends Attachment {
     path: string;
@@ -46,6 +46,17 @@ export interface BackendTuning {
     /** ACP agents: the session id to continue (from ChatMeta.sessions) instead of opening a new one. */
     resume?: string;
 }
+/**
+ * How a turn ended. `failure` is the typed session failure the agent
+ * attached to the turn's own outcome (a usage limit, a rate limit, a
+ * provider error): ACP hands those back on the prompt response rather
+ * than as a mid-turn notification, and without it the turn would look
+ * like an ordinary empty `end_turn`.
+ */
+export interface TurnEnd {
+    stopReason: string;
+    failure?: SessionFailure;
+}
 export interface ChatBackend {
     /** The agent's own session id, when it has one to resume later (ACP agents). */
     sessionId?: string;
@@ -53,8 +64,8 @@ export interface ChatBackend {
     resumed?: boolean;
     /** The resumed session turned out unusable at its first prompt — its id must not be resumed again. */
     resumeFailed?: boolean;
-    /** Send one user message (plus files dropped into it); resolves with the stop reason at turn end. */
-    prompt(text: string, files?: PromptFile[]): Promise<string>;
+    /** Send one user message (plus files dropped into it); resolves with how the turn ended. */
+    prompt(text: string, files?: PromptFile[]): Promise<TurnEnd>;
     /** Branch the conversation: a new session id with this session's history (ACP agents that offer session/fork). */
     fork?(): Promise<string>;
     /**

package/dist/inspector/chat/pi.js

@@ -87,14 +87,14 @@ export function startPiBackend(cwd, hooks, tuning = {}) {
                     child = null;
                     handleLine(buffer);
                     if (cancelled)
-                        return resolve("cancelled");
+                        return resolve({ stopReason: "cancelled" });
                     if (failure || code !== 0 || !sawAssistant) {
                         reject(new Error(`pi failed (exit ${code})` +
                             (failure ? `: ${failure}` : "") +
                             (stderr.trim() ? `\nstderr: ${stderr.trim().slice(-1000)}` : "")));
                         return;
                     }
-                    resolve("end_turn");
+                    resolve({ stopReason: "end_turn" });
                 });
             });
         },

package/dist/inspector/chat/sessions.js

@@ -67,6 +67,10 @@ function lastEventText(state, afterSeq, type) {
             parts.push(e.text);
         if (type === "error" && e.type === "error")
             parts.push(e.message);
+        // A turn the agent ended on a provider failure (usage limit, rate
+        // limit) reports no error event — the failure card is the outcome.
+        if (type === "error" && e.type === "failure" && e.severity === "error")
+            parts.push(e.title);
     }
     const text = parts.join("").trim();
     if (!text)
@@ -790,14 +794,18 @@ export async function postMessage(id, text, opts = {}) {
             // the thread keeps the short form the user typed.
             const body = await expandSkillInvocation(state.meta.scope, text);
             const promptText = context ? `<context>\n${context}\n</context>\n\n${body}` : body;
-            const stopReason = await backend.prompt(promptText, promptFiles(id, attachments));
+            const { stopReason, failure } = await backend.prompt(promptText, promptFiles(id, attachments));
             emit(state, { type: "turn_end", stopReason });
+            // After turn_end, so the card stays live (a turn_end settles the
+            // failures reported before it): this one is why the turn ended.
+            if (failure)
+                emit(state, { type: "failure", ...failure });
             // Routine sessions are one-shot and unattended: release the agent
             // process as soon as the turn ends instead of waiting for the reaper,
             // and tell the bell how it went.
             if (isUnattended(state.meta.scope)) {
                 dropBackend(state);
-                const failed = state.events.some((e) => e.seq > turnStart && e.type === "error");
+                const failed = state.events.some((e) => e.seq > turnStart && (e.type === "error" || (e.type === "failure" && e.severity === "error")));
                 void pushNotification({
                     kind: failed ? "routine_failed" : "routine_done",
                     title: `${chatLabel(state.meta)} ${failed ? "ended with an error" : "finished"}`,
@@ -923,8 +931,10 @@ async function runSeatTurn(state, channel, seat, hops) {
         }
         const prompt = (context ? `<context>\n${context}\n</context>\n\n` : "") +
             (delta ? `New messages in #${channel.slug}:\n\n${delta}` : `You joined #${channel.slug}. Nothing addressed to you yet — reply with one short line saying you are here.`);
-        const stopReason = await backend.prompt(prompt);
+        const { stopReason, failure } = await backend.prompt(prompt);
         emit(state, { type: "turn_end", stopReason }, me);
+        if (failure)
+            emit(state, { type: "failure", ...failure }, me);
         // Handover: agents this one @mentioned get its message, within the hop budget.
         const said = seatTextSince(state, start, seat.key);
         const next = mentionTargets(said, channel, seat.key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netnodeag/kraftwerk",
-  "version": "0.50.0",
+  "version": "0.50.1",
   "description": "Open-source agentic workspace for teams — where people and AI agents get work done together: agents (Claude Code, Codex, Pi), skills, shared knowledge, repeatable workflows, and deterministic verification",
   "keywords": [
     "agents",