@syengup/friday-channel-next 1.0.4 → 1.0.5

package/README.md

@@ -11,6 +11,8 @@
 - File upload/download (`POST /friday-next/files`, `GET /friday-next/files/:id`)
 - Cancel (`POST /friday-next/cancel`) and status with `activeRuns` (`GET /friday-next/status`)
 - **Agent config editing** (mirrors ControlUI, no core changes): model / core `.md` files / tool permissions / skills, per agent — via `agents.list[]` (`mutateConfigFile`) + workspace fs
+- **Codex backend support**: asserts `model_reasoning_summary` in each agent's `codex-home/config.toml` so ChatGPT/OAuth (Codex app-server) models stream reasoning text
+- **Exec / plugin approvals**: forwards approval requests as `event: approval` and accepts decisions at `POST /friday-next/approvals/{approvalId}`
 - History sync, link-preview cards, and in-app plugin self-upgrade
 
 ## Endpoints
@@ -22,6 +24,7 @@
 - `GET /friday-next/models` · `GET /friday-next/agents` · `GET|PUT /friday-next/sessions/settings`
 - `GET|PUT /friday-next/agents/{id}/config` · `GET|PUT /friday-next/agents/{id}/files[/{name}]` · `GET /friday-next/agents/{id}/tools/catalog`
 - `GET /friday-next/history/sessions` · `GET /friday-next/history/messages` · `GET /friday-next/link-preview`
+- `POST /friday-next/device-approve` · `POST /friday-next/nodes-approve` · `POST /friday-next/approvals/{approvalId}`
 - `GET /friday-next/plugin/info` · `POST /friday-next/plugin/upgrade`
 
 See **`API.md`** (English) and **`API.zh-CN.md`** (Chinese) for payloads, event shapes, offline queue paths, and breaking changes.

package/dist/src/agent/abort-run.d.ts

@@ -1,12 +1,25 @@
 export type AbortRunResult = {
     aborted: boolean;
-    drained: boolean;
+};
+export type AbortRunDeps = {
+    resolveActiveEmbeddedRunSessionId: (sessionKey: string) => string | undefined;
+    abortAgentHarnessRun: (sessionId: string) => boolean;
 };
 /**
- * Abort the active run for a channel `sessionKey`.
+ * Abort the active run for a channel `sessionKey` — the CANONICAL OpenClaw stop.
+ *
+ * Mirrors how ControlUI (`chat.abort` → `abortChatRunById`) and the voice/`/compact`/
+ * steer paths stop a run: resolve sessionKey → internal sessionId (active runs are keyed
+ * by sessionId, not the channel runId), then fire a PLAIN abort (`abortAgentHarnessRun`
+ * = `abortEmbeddedAgentRun` → `handle.abort()`). That sets the run's `externalAbort` flag
+ * so it unwinds to a clean `"aborted_by_user"` terminal — a SILENT reply plus a
+ * `status:"cancelled"` lifecycle — with NO error event.
  *
- * A session has at most one active run at a time, and the SDK keys active runs by
- * their internal `sessionId` (not the channel runId). So resolve sessionKey → sessionId
- * first, then abort-and-drain so the caller learns whether the run actually settled.
+ * Deliberately NOT abort-and-drain with `forceClear`: `forceClear` force-fails the reply
+ * operation (`operation.fail("run_failed", new Error("Embedded run force-cleared by …"))`)
+ * and never fires the abort signal, so (a) the failed operation surfaces as a spurious
+ * `dispatch_error`, and (b) without `externalAbort` the interrupted LLM call is classified
+ * as a real failure → `"LLM request failed."`. Both show up as an error toast in the app.
+ * `forceClear` is OpenClaw's stuck/cron-timeout recovery hammer, not a user-initiated stop.
  */
-export declare function abortRunForSessionKey(sessionKey: string): Promise<AbortRunResult>;
+export declare function abortRunForSessionKey(sessionKey: string, deps?: AbortRunDeps): Promise<AbortRunResult>;

package/dist/src/agent/abort-run.js

@@ -1,26 +1,49 @@
+const NO_OP = { aborted: false };
+async function loadAbortRunDeps() {
+    // The SDK is optional at runtime and unavailable/unmockable under Vitest; tests
+    // inject `deps` directly to exercise the real abort path.
+    if (process.env.VITEST === "true")
+        return null;
+    try {
+        return await import("openclaw/plugin-sdk/agent-harness");
+    }
+    catch {
+        return null;
+    }
+}
 /**
- * Abort the active run for a channel `sessionKey`.
+ * Abort the active run for a channel `sessionKey` — the CANONICAL OpenClaw stop.
  *
- * A session has at most one active run at a time, and the SDK keys active runs by
- * their internal `sessionId` (not the channel runId). So resolve sessionKey → sessionId
- * first, then abort-and-drain so the caller learns whether the run actually settled.
+ * Mirrors how ControlUI (`chat.abort` → `abortChatRunById`) and the voice/`/compact`/
+ * steer paths stop a run: resolve sessionKey → internal sessionId (active runs are keyed
+ * by sessionId, not the channel runId), then fire a PLAIN abort (`abortAgentHarnessRun`
+ * = `abortEmbeddedAgentRun` → `handle.abort()`). That sets the run's `externalAbort` flag
+ * so it unwinds to a clean `"aborted_by_user"` terminal — a SILENT reply plus a
+ * `status:"cancelled"` lifecycle — with NO error event.
+ *
+ * Deliberately NOT abort-and-drain with `forceClear`: `forceClear` force-fails the reply
+ * operation (`operation.fail("run_failed", new Error("Embedded run force-cleared by …"))`)
+ * and never fires the abort signal, so (a) the failed operation surfaces as a spurious
+ * `dispatch_error`, and (b) without `externalAbort` the interrupted LLM call is classified
+ * as a real failure → `"LLM request failed."`. Both show up as an error toast in the app.
+ * `forceClear` is OpenClaw's stuck/cron-timeout recovery hammer, not a user-initiated stop.
  */
-export async function abortRunForSessionKey(sessionKey) {
-    if (process.env.VITEST === "true")
-        return { aborted: false, drained: false };
+export async function abortRunForSessionKey(sessionKey, deps) {
     const key = sessionKey.trim();
     if (!key)
-        return { aborted: false, drained: false };
+        return NO_OP;
+    const resolved = deps ?? (await loadAbortRunDeps());
+    if (!resolved)
+        return NO_OP;
     try {
-        const { resolveActiveEmbeddedRunSessionId, abortAndDrainAgentHarnessRun } = await import("openclaw/plugin-sdk/agent-harness");
-        const sessionId = resolveActiveEmbeddedRunSessionId(key);
+        const sessionId = resolved.resolveActiveEmbeddedRunSessionId(key);
         if (!sessionId)
-            return { aborted: false, drained: false };
-        const result = await abortAndDrainAgentHarnessRun({ sessionId, sessionKey: key });
-        return { aborted: result.aborted, drained: result.drained };
+            return NO_OP;
+        const aborted = resolved.abortAgentHarnessRun(sessionId);
+        return { aborted };
     }
     catch {
         // optional at runtime
-        return { aborted: false, drained: false };
+        return NO_OP;
     }
 }

package/dist/src/agent/recent-aborts.d.ts

@@ -0,0 +1,6 @@
+/** How long after a user stop to treat surfaced errors as abort-noise. */
+export declare const RECENT_ABORT_SUPPRESSION_MS = 20000;
+export declare function markUserAbort(sessionKey: string, nowMs?: number): void;
+export declare function wasRecentlyUserAborted(sessionKey: string, nowMs?: number): boolean;
+/** Test/maintenance hook. */
+export declare function clearRecentAborts(): void;

package/dist/src/agent/recent-aborts.js

@@ -0,0 +1,35 @@
+/**
+ * Tracks recent user-initiated aborts per channel sessionKey.
+ *
+ * When the user stops a run, OpenClaw's embedded runner / Codex backend can still surface an
+ * error as a consequence of the interruption — the aborted run's own failover ("LLM request
+ * failed.") or a generic failure on the very next turn ("Something went wrong …"). Those are
+ * abort-noise, not real failures the user should see as an error toast. The channel records the
+ * abort here so the deliver/error forwarders can drop `isError` payloads that land within a short
+ * window of a stop the user explicitly requested.
+ */
+const recentAbortAtMs = new Map();
+/** How long after a user stop to treat surfaced errors as abort-noise. */
+export const RECENT_ABORT_SUPPRESSION_MS = 20_000;
+export function markUserAbort(sessionKey, nowMs = Date.now()) {
+    const key = sessionKey.trim();
+    if (key)
+        recentAbortAtMs.set(key, nowMs);
+}
+export function wasRecentlyUserAborted(sessionKey, nowMs = Date.now()) {
+    const key = sessionKey.trim();
+    if (!key)
+        return false;
+    const at = recentAbortAtMs.get(key);
+    if (at === undefined)
+        return false;
+    if (nowMs - at > RECENT_ABORT_SUPPRESSION_MS) {
+        recentAbortAtMs.delete(key);
+        return false;
+    }
+    return true;
+}
+/** Test/maintenance hook. */
+export function clearRecentAborts() {
+    recentAbortAtMs.clear();
+}

package/dist/src/http/handlers/cancel.js

@@ -1,4 +1,5 @@
 import { abortRunForSessionKey } from "../../agent/abort-run.js";
+import { markUserAbort } from "../../agent/recent-aborts.js";
 import { getRunRoute } from "../../run-metadata.js";
 import { sseEmitter } from "../../sse/emitter.js";
 import { readJsonBody } from "../middleware/body.js";
@@ -31,7 +32,11 @@ export async function handleCancel(req, res) {
     }
     const result = sessionKey
         ? await abortRunForSessionKey(sessionKey)
-        : { aborted: false, drained: false };
+        : { aborted: false };
+    // Record the user stop so abort-induced error deliveries are suppressed for a short window
+    // (the aborted run's own failover, or a generic failure on the immediate next turn).
+    if (sessionKey)
+        markUserAbort(sessionKey);
     if (runId)
         sseEmitter.untrackRun(runId);
     res.statusCode = 200;

package/dist/src/http/handlers/messages.js

@@ -11,6 +11,7 @@
  */
 import crypto from "node:crypto";
 import { resolveFridayNextConfig } from "../../config.js";
+import { wasRecentlyUserAborted } from "../../agent/recent-aborts.js";
 import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
 import { getFridayNextRuntime } from "../../runtime.js";
 import { resolveAgentDefaults, setSessionSettings, splitModelRef, toSessionStoreKey, } from "../../session/session-manager.js";
@@ -429,6 +430,13 @@ export async function handleMessages(req, res) {
                             }
                         }
                         const payload = translateDeliverPayload(pl, info.kind, meta);
+                        const deliverIsError = payload?.isError || pl?.isError;
+                        // Drop error deliveries that are a direct consequence of a user stop (the aborted
+                        // run's own failover, e.g. "LLM request failed."). The user already chose to stop;
+                        // surfacing it as an error toast is abort-noise, not a real failure.
+                        if (deliverIsError && wasRecentlyUserAborted(baseSessionKey)) {
+                            return;
+                        }
                         log("EVENT_SENT", normalizedDeviceId, runId, `deliver kind=${info.kind}`);
                         sseEmitter.broadcastToRun(runId, {
                             type: "deliver",
@@ -449,6 +457,9 @@ export async function handleMessages(req, res) {
                         }
                     },
                     onError: (err) => {
+                        if (wasRecentlyUserAborted(baseSessionKey)) {
+                            return;
+                        }
                         log("RUN_ERROR", normalizedDeviceId, runId, String(err), "error");
                         sseEmitter.broadcastToRun(runId, {
                             type: "outbound",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

package/src/agent/abort-run.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from "vitest";
+import { abortRunForSessionKey } from "./abort-run.js";
+
+describe("abortRunForSessionKey", () => {
+  it("resolves sessionKey → sessionId then fires a PLAIN abort (canonical clean stop)", async () => {
+    const abortAgentHarnessRun = vi.fn().mockReturnValue(true);
+    const resolveActiveEmbeddedRunSessionId = vi.fn().mockReturnValue("sid-9");
+
+    const result = await abortRunForSessionKey("sk-9", {
+      resolveActiveEmbeddedRunSessionId,
+      abortAgentHarnessRun,
+    });
+
+    expect(resolveActiveEmbeddedRunSessionId).toHaveBeenCalledWith("sk-9");
+    // Plain abort by internal sessionId — fires handle.abort(), no drain/forceClear.
+    expect(abortAgentHarnessRun).toHaveBeenCalledWith("sid-9");
+    expect(result).toEqual({ aborted: true });
+  });
+
+  it("returns a no-op without aborting when there is no active run for the sessionKey", async () => {
+    const abortAgentHarnessRun = vi.fn();
+    const result = await abortRunForSessionKey("sk-x", {
+      resolveActiveEmbeddedRunSessionId: () => undefined,
+      abortAgentHarnessRun,
+    });
+    expect(abortAgentHarnessRun).not.toHaveBeenCalled();
+    expect(result).toEqual({ aborted: false });
+  });
+
+  it("returns a no-op for an empty sessionKey", async () => {
+    const abortAgentHarnessRun = vi.fn();
+    const result = await abortRunForSessionKey("   ", {
+      resolveActiveEmbeddedRunSessionId: () => "sid",
+      abortAgentHarnessRun,
+    });
+    expect(abortAgentHarnessRun).not.toHaveBeenCalled();
+    expect(result).toEqual({ aborted: false });
+  });
+});

package/src/agent/abort-run.ts

@@ -1,25 +1,55 @@
-export type AbortRunResult = { aborted: boolean; drained: boolean };
+export type AbortRunResult = { aborted: boolean };
+
+export type AbortRunDeps = {
+  resolveActiveEmbeddedRunSessionId: (sessionKey: string) => string | undefined;
+  abortAgentHarnessRun: (sessionId: string) => boolean;
+};
+
+const NO_OP: AbortRunResult = { aborted: false };
+
+async function loadAbortRunDeps(): Promise<AbortRunDeps | null> {
+  // The SDK is optional at runtime and unavailable/unmockable under Vitest; tests
+  // inject `deps` directly to exercise the real abort path.
+  if (process.env.VITEST === "true") return null;
+  try {
+    return await import("openclaw/plugin-sdk/agent-harness");
+  } catch {
+    return null;
+  }
+}
 
 /**
- * Abort the active run for a channel `sessionKey`.
+ * Abort the active run for a channel `sessionKey` — the CANONICAL OpenClaw stop.
+ *
+ * Mirrors how ControlUI (`chat.abort` → `abortChatRunById`) and the voice/`/compact`/
+ * steer paths stop a run: resolve sessionKey → internal sessionId (active runs are keyed
+ * by sessionId, not the channel runId), then fire a PLAIN abort (`abortAgentHarnessRun`
+ * = `abortEmbeddedAgentRun` → `handle.abort()`). That sets the run's `externalAbort` flag
+ * so it unwinds to a clean `"aborted_by_user"` terminal — a SILENT reply plus a
+ * `status:"cancelled"` lifecycle — with NO error event.
  *
- * A session has at most one active run at a time, and the SDK keys active runs by
- * their internal `sessionId` (not the channel runId). So resolve sessionKey → sessionId
- * first, then abort-and-drain so the caller learns whether the run actually settled.
+ * Deliberately NOT abort-and-drain with `forceClear`: `forceClear` force-fails the reply
+ * operation (`operation.fail("run_failed", new Error("Embedded run force-cleared by …"))`)
+ * and never fires the abort signal, so (a) the failed operation surfaces as a spurious
+ * `dispatch_error`, and (b) without `externalAbort` the interrupted LLM call is classified
+ * as a real failure → `"LLM request failed."`. Both show up as an error toast in the app.
+ * `forceClear` is OpenClaw's stuck/cron-timeout recovery hammer, not a user-initiated stop.
  */
-export async function abortRunForSessionKey(sessionKey: string): Promise<AbortRunResult> {
-  if (process.env.VITEST === "true") return { aborted: false, drained: false };
+export async function abortRunForSessionKey(
+  sessionKey: string,
+  deps?: AbortRunDeps,
+): Promise<AbortRunResult> {
   const key = sessionKey.trim();
-  if (!key) return { aborted: false, drained: false };
+  if (!key) return NO_OP;
+  const resolved = deps ?? (await loadAbortRunDeps());
+  if (!resolved) return NO_OP;
   try {
-    const { resolveActiveEmbeddedRunSessionId, abortAndDrainAgentHarnessRun } =
-      await import("openclaw/plugin-sdk/agent-harness");
-    const sessionId = resolveActiveEmbeddedRunSessionId(key);
-    if (!sessionId) return { aborted: false, drained: false };
-    const result = await abortAndDrainAgentHarnessRun({ sessionId, sessionKey: key });
-    return { aborted: result.aborted, drained: result.drained };
+    const sessionId = resolved.resolveActiveEmbeddedRunSessionId(key);
+    if (!sessionId) return NO_OP;
+    const aborted = resolved.abortAgentHarnessRun(sessionId);
+    return { aborted };
   } catch {
     // optional at runtime
-    return { aborted: false, drained: false };
+    return NO_OP;
   }
 }

package/src/agent/recent-aborts.test.ts

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  clearRecentAborts,
+  markUserAbort,
+  RECENT_ABORT_SUPPRESSION_MS,
+  wasRecentlyUserAborted,
+} from "./recent-aborts.js";
+
+afterEach(() => clearRecentAborts());
+
+describe("recent-aborts", () => {
+  it("reports a sessionKey as recently aborted within the window", () => {
+    markUserAbort("sk-1", 1_000);
+    expect(wasRecentlyUserAborted("sk-1", 1_000)).toBe(true);
+    expect(wasRecentlyUserAborted("sk-1", 1_000 + RECENT_ABORT_SUPPRESSION_MS)).toBe(true);
+  });
+
+  it("expires after the window", () => {
+    markUserAbort("sk-2", 1_000);
+    expect(wasRecentlyUserAborted("sk-2", 1_000 + RECENT_ABORT_SUPPRESSION_MS + 1)).toBe(false);
+  });
+
+  it("is false for an unknown or empty sessionKey", () => {
+    expect(wasRecentlyUserAborted("never", 1_000)).toBe(false);
+    expect(wasRecentlyUserAborted("   ", 1_000)).toBe(false);
+    markUserAbort("   ", 1_000);
+    expect(wasRecentlyUserAborted("   ", 1_000)).toBe(false);
+  });
+});

package/src/agent/recent-aborts.ts

@@ -0,0 +1,36 @@
+/**
+ * Tracks recent user-initiated aborts per channel sessionKey.
+ *
+ * When the user stops a run, OpenClaw's embedded runner / Codex backend can still surface an
+ * error as a consequence of the interruption — the aborted run's own failover ("LLM request
+ * failed.") or a generic failure on the very next turn ("Something went wrong …"). Those are
+ * abort-noise, not real failures the user should see as an error toast. The channel records the
+ * abort here so the deliver/error forwarders can drop `isError` payloads that land within a short
+ * window of a stop the user explicitly requested.
+ */
+const recentAbortAtMs = new Map<string, number>();
+
+/** How long after a user stop to treat surfaced errors as abort-noise. */
+export const RECENT_ABORT_SUPPRESSION_MS = 20_000;
+
+export function markUserAbort(sessionKey: string, nowMs: number = Date.now()): void {
+  const key = sessionKey.trim();
+  if (key) recentAbortAtMs.set(key, nowMs);
+}
+
+export function wasRecentlyUserAborted(sessionKey: string, nowMs: number = Date.now()): boolean {
+  const key = sessionKey.trim();
+  if (!key) return false;
+  const at = recentAbortAtMs.get(key);
+  if (at === undefined) return false;
+  if (nowMs - at > RECENT_ABORT_SUPPRESSION_MS) {
+    recentAbortAtMs.delete(key);
+    return false;
+  }
+  return true;
+}
+
+/** Test/maintenance hook. */
+export function clearRecentAborts(): void {
+  recentAbortAtMs.clear();
+}

package/src/http/handlers/cancel.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { abortRunForSessionKey } from "../../agent/abort-run.js";
+import { markUserAbort } from "../../agent/recent-aborts.js";
 import { getRunRoute } from "../../run-metadata.js";
 import { sseEmitter } from "../../sse/emitter.js";
 import { readJsonBody } from "../middleware/body.js";
@@ -34,7 +35,10 @@ export async function handleCancel(req: IncomingMessage, res: ServerResponse): P
   }
   const result = sessionKey
     ? await abortRunForSessionKey(sessionKey)
-    : { aborted: false, drained: false };
+    : { aborted: false };
+  // Record the user stop so abort-induced error deliveries are suppressed for a short window
+  // (the aborted run's own failover, or a generic failure on the immediate next turn).
+  if (sessionKey) markUserAbort(sessionKey);
   if (runId) sseEmitter.untrackRun(runId);
   res.statusCode = 200;
   res.setHeader("Content-Type", "application/json");

package/src/http/handlers/messages.ts

@@ -25,6 +25,7 @@ export type FridayReplyPayload = {
   channelData?: unknown;
 };
 import { resolveFridayNextConfig } from "../../config.js";
+import { wasRecentlyUserAborted } from "../../agent/recent-aborts.js";
 import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
 import { getFridayNextRuntime } from "../../runtime.js";
 import {
@@ -589,6 +590,14 @@ export async function handleMessages(req: IncomingMessage, res: ServerResponse):
               }
             }
             const payload = translateDeliverPayload(pl, info.kind, meta);
+            const deliverIsError =
+              (payload as { isError?: boolean })?.isError || (pl as { isError?: boolean })?.isError;
+            // Drop error deliveries that are a direct consequence of a user stop (the aborted
+            // run's own failover, e.g. "LLM request failed."). The user already chose to stop;
+            // surfacing it as an error toast is abort-noise, not a real failure.
+            if (deliverIsError && wasRecentlyUserAborted(baseSessionKey)) {
+              return;
+            }
             log("EVENT_SENT", normalizedDeviceId, runId, `deliver kind=${info.kind}`);
             sseEmitter.broadcastToRun(
               runId,
@@ -613,6 +622,9 @@ export async function handleMessages(req: IncomingMessage, res: ServerResponse):
             }
           },
           onError: (err: unknown) => {
+            if (wasRecentlyUserAborted(baseSessionKey)) {
+              return;
+            }
             log("RUN_ERROR", normalizedDeviceId, runId, String(err), "error");
             sseEmitter.broadcastToRun(
               runId,