@syengup/friday-channel-next 0.0.46 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SyengUp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -9,6 +9,7 @@ import { sseEmitter } from "./src/sse/emitter.js";
 import { forwardAgentEventRaw, getLastRegisteredFridayDeviceId, resolveFridayDeviceIdForSessionKey, } from "./src/friday-session.js";
 import { setFridayAgentForwardRuntime } from "./src/agent-forward-runtime.js";
 import { getOpenClawAgentRunContext } from "./src/agent-run-context-bridge.js";
+import { accumulateRunUsage } from "./src/agent/run-usage-accumulator.js";
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
 /** `api.on` returns void — register tool hooks at most once per process. */
@@ -95,6 +96,15 @@ export default defineChannelPluginEntry({
                 sessionKey: evt.sessionKey,
             });
         });
+        api.on("llm_output", (event) => {
+            accumulateRunUsage(event.runId, {
+                input: event.usage?.input,
+                output: event.usage?.output,
+                cacheRead: event.usage?.cacheRead,
+                cacheWrite: event.usage?.cacheWrite,
+                total: event.usage?.total,
+            }, event.model, event.provider);
+        });
         if (fridayNextToolHooksRegistered) {
             return;
         }

package/dist/src/agent/run-usage-accumulator.d.ts

@@ -0,0 +1,13 @@
+import type { FridaySessionUsagePayload } from "../session-usage-snapshot.js";
+type UsageFields = {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+};
+export declare function accumulateRunUsage(runId: string, usage: UsageFields, model?: string, provider?: string): void;
+export declare function consumeRunUsage(runId: string): FridaySessionUsagePayload | undefined;
+/** Vitest-only. */
+export declare function resetRunUsageAccumulatorForTest(): void;
+export {};

package/dist/src/agent/run-usage-accumulator.js

@@ -0,0 +1,58 @@
+const usageByRunId = new Map();
+function ensure(runId) {
+    let entry = usageByRunId.get(runId);
+    if (!entry) {
+        entry = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+        usageByRunId.set(runId, entry);
+    }
+    return entry;
+}
+export function accumulateRunUsage(runId, usage, model, provider) {
+    if (!runId.trim())
+        return;
+    const entry = ensure(runId);
+    if (typeof usage.input === "number" && usage.input > 0)
+        entry.input += usage.input;
+    if (typeof usage.output === "number" && usage.output > 0)
+        entry.output += usage.output;
+    if (typeof usage.cacheRead === "number" && usage.cacheRead > 0)
+        entry.cacheRead += usage.cacheRead;
+    if (typeof usage.cacheWrite === "number" && usage.cacheWrite > 0)
+        entry.cacheWrite += usage.cacheWrite;
+    if (typeof usage.total === "number" && usage.total > 0)
+        entry.total += usage.total;
+    if (model && model.trim())
+        entry.model = model.trim();
+    if (provider && provider.trim())
+        entry.provider = provider.trim();
+}
+export function consumeRunUsage(runId) {
+    const entry = usageByRunId.get(runId);
+    if (!entry)
+        return undefined;
+    usageByRunId.delete(runId);
+    const tokens = {};
+    if (entry.input > 0)
+        tokens.input = entry.input;
+    if (entry.output > 0)
+        tokens.output = entry.output;
+    if (entry.cacheRead > 0)
+        tokens.cacheRead = entry.cacheRead;
+    if (entry.cacheWrite > 0)
+        tokens.cacheWrite = entry.cacheWrite;
+    if (entry.total > 0)
+        tokens.total = entry.total;
+    tokens.totalFresh = true;
+    if (Object.keys(tokens).length === 1)
+        return undefined; // only totalFresh, no actual tokens
+    const payload = { tokens };
+    if (entry.model)
+        payload.modelId = entry.model;
+    if (entry.provider)
+        payload.modelProvider = entry.provider;
+    return payload;
+}
+/** Vitest-only. */
+export function resetRunUsageAccumulatorForTest() {
+    usageByRunId.clear();
+}

package/dist/src/friday-session.js

@@ -4,6 +4,7 @@ import { toSessionStoreKey } from "./session/session-manager.js";
 import { getOpenClawAgentRunContext } from "./agent-run-context-bridge.js";
 import { observeAgentEventForActiveRuns } from "./agent/active-runs.js";
 import { getRunMetadata, ingestAgentEventMetadata } from "./run-metadata.js";
+import { consumeRunUsage } from "./agent/run-usage-accumulator.js";
 import { buildSessionUsageSnapshot } from "./session-usage-snapshot.js";
 import { lookupByRunId, registerSessionKeyForRun, registerSpawnIntent, consumeSpawnIntent, ensureSubagentFromSpawnTool, registerEnded as registerSubagentEnded, } from "./agent/subagent-registry.js";
 /** Last `data.text` per run for `stream: "thinking"` — OpenClaw core may send cumulative `delta`; we rewrite true increments for the app. */
@@ -162,6 +163,59 @@ function tryReadSessionUsageFromStore(sessionKeyForStore) {
         return undefined;
     }
 }
+function buildSessionUsageFromRunMetadata(runId) {
+    const meta = getRunMetadata(runId);
+    if (!meta)
+        return undefined;
+    const payload = {};
+    if (typeof meta.modelName === "string" && meta.modelName.trim()) {
+        payload.modelId = meta.modelName.trim();
+    }
+    if (typeof meta.modelProvider === "string" && meta.modelProvider.trim()) {
+        payload.modelProvider = meta.modelProvider.trim();
+    }
+    const tokens = {};
+    if (typeof meta.inputTokens === "number")
+        tokens.input = meta.inputTokens;
+    if (typeof meta.outputTokens === "number")
+        tokens.output = meta.outputTokens;
+    if (typeof meta.cacheReadTokens === "number")
+        tokens.cacheRead = meta.cacheReadTokens;
+    if (typeof meta.cacheWriteTokens === "number")
+        tokens.cacheWrite = meta.cacheWriteTokens;
+    if (typeof meta.totalTokens === "number")
+        tokens.total = meta.totalTokens;
+    if (Object.keys(tokens).length > 0)
+        payload.tokens = tokens;
+    const context = {};
+    if (typeof meta.contextWindowMax === "number")
+        context.windowMax = meta.contextWindowMax;
+    if (typeof meta.totalTokens === "number")
+        context.used = meta.totalTokens;
+    if (Object.keys(context).length > 0)
+        payload.context = context;
+    if (!payload.modelId && !payload.modelProvider && !payload.tokens && !payload.context) {
+        return undefined;
+    }
+    return payload;
+}
+function mergeUsage(llmUsage, memUsage) {
+    if (!llmUsage && !memUsage)
+        return undefined;
+    if (!llmUsage)
+        return memUsage;
+    if (!memUsage)
+        return llmUsage;
+    // llm_output tokens are authoritative (per API call, no race);
+    // RunMetadata fills context window gaps.
+    return {
+        modelId: llmUsage.modelId ?? memUsage.modelId,
+        modelProvider: llmUsage.modelProvider ?? memUsage.modelProvider,
+        tokens: llmUsage.tokens,
+        context: memUsage.context ?? llmUsage.context,
+        estimatedCostUsd: llmUsage.estimatedCostUsd ?? memUsage.estimatedCostUsd,
+    };
+}
 function completeAgentEventForward(params) {
     const { evt, sk, deviceIdRaw, outgoingData, isTerminalLifecycle, subagentMeta } = params;
     observeAgentEventForActiveRuns({ stream: evt.stream, runId: evt.runId, data: outgoingData });
@@ -366,23 +420,38 @@ export function forwardAgentEventRaw(evt) {
             }, ended.deviceId);
         }
     }
-    if (isTerminalLifecycle && getFridayAgentForwardRuntime()) {
-        setImmediate(() => {
-            let data = outgoingData;
-            const usage = tryReadSessionUsageFromStore(sk);
+    // Build sessionUsage: llm_output hook (primary, no race) → store read (fallback).
+    if (isTerminalLifecycle) {
+        const llmUsage = consumeRunUsage(evt.runId);
+        const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
+        const hasRealTokens = llmUsage?.tokens && Object.keys(llmUsage.tokens).length > 1;
+        if (hasRealTokens) {
+            const usage = mergeUsage(llmUsage, memUsage);
             if (usage) {
-                data = { ...outgoingData, sessionUsage: usage };
+                outgoingData = { ...outgoingData, sessionUsage: usage };
             }
-            completeAgentEventForward({
-                evt,
-                sk,
-                deviceIdRaw,
-                outgoingData: data,
-                isTerminalLifecycle: true,
-                subagentMeta,
-            });
-        });
-        return;
+        }
+        else if (getFridayAgentForwardRuntime()) {
+            // llm_output hook fires async ~20ms after lifecycle.end.
+            // Wait 100ms then re-check before falling back to store read.
+            setTimeout(() => {
+                let data = outgoingData;
+                const retryLlm = consumeRunUsage(evt.runId);
+                const usage = mergeUsage(retryLlm, memUsage) ?? tryReadSessionUsageFromStore(sk);
+                if (usage) {
+                    data = { ...outgoingData, sessionUsage: usage };
+                }
+                completeAgentEventForward({
+                    evt,
+                    sk,
+                    deviceIdRaw,
+                    outgoingData: data,
+                    isTerminalLifecycle: true,
+                    subagentMeta,
+                });
+            }, 100);
+            return;
+        }
     }
     completeAgentEventForward({
         evt,

package/dist/src/health/self-health.d.ts

@@ -0,0 +1,39 @@
+export interface SelfHealthOptions {
+    enabled: boolean;
+    checkIntervalMs: number;
+    selfHeal: boolean;
+}
+interface CheckResult {
+    name: string;
+    status: "ok" | "degraded" | "failed";
+    detail: string;
+}
+interface RepairAction {
+    component: string;
+    action: string;
+    result: "ok" | "failed" | "skipped";
+    detail: string;
+}
+export interface SelfHealthReport {
+    timestamp: number;
+    checks: CheckResult[];
+    repairs: RepairAction[];
+    overallStatus: "ok" | "degraded" | "failed";
+}
+export declare class HealthCheckRunner {
+    private timer;
+    private options;
+    constructor(options?: Partial<SelfHealthOptions>);
+    updateOptions(opts: Partial<SelfHealthOptions>): void;
+    start(_api: unknown): void;
+    stop(): void;
+    runCheck(): Promise<SelfHealthReport>;
+    private checkConfig;
+    private checkSseEmitter;
+    private checkActiveRuns;
+    private repairConfig;
+    private repairSseEmitter;
+}
+export declare function getHealthCheckRunner(): HealthCheckRunner;
+export declare function resetHealthCheckRunnerForTest(): void;
+export {};

package/dist/src/health/self-health.js

@@ -0,0 +1,174 @@
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+import { sseEmitter } from "../sse/emitter.js";
+import { getActiveRunCount } from "../agent/active-runs.js";
+import { createFridayNextLogger } from "../logging.js";
+const log = createFridayNextLogger("health-runner", "info");
+export class HealthCheckRunner {
+    timer = null;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            enabled: options.enabled ?? true,
+            checkIntervalMs: options.checkIntervalMs ?? 60_000,
+            selfHeal: options.selfHeal ?? true,
+        };
+    }
+    updateOptions(opts) {
+        Object.assign(this.options, opts);
+    }
+    start(_api) {
+        this.stop();
+        if (!this.options.enabled) {
+            log.info("Self-health check disabled by config");
+            return;
+        }
+        log.info(`Starting self-health checks every ${this.options.checkIntervalMs}ms`);
+        this.timer = setInterval(() => {
+            this.runCheck().catch((err) => {
+                log.error(`Self-health check error: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }, this.options.checkIntervalMs);
+        if (this.timer && typeof this.timer.unref === "function") {
+            this.timer.unref();
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    async runCheck() {
+        const report = {
+            timestamp: Date.now(),
+            checks: [],
+            repairs: [],
+            overallStatus: "ok",
+        };
+        report.checks.push(this.checkConfig());
+        report.checks.push(this.checkSseEmitter());
+        report.checks.push(this.checkActiveRuns());
+        if (this.options.selfHeal) {
+            const configCheck = report.checks[0];
+            if (configCheck.status === "failed") {
+                report.repairs.push(await this.repairConfig());
+            }
+            const sseCheck = report.checks[1];
+            if (sseCheck.status === "failed") {
+                report.repairs.push(await this.repairSseEmitter());
+            }
+        }
+        const statuses = report.checks.map((c) => c.status);
+        if (statuses.includes("failed")) {
+            report.overallStatus = "failed";
+        }
+        else if (statuses.includes("degraded")) {
+            report.overallStatus = "degraded";
+        }
+        if (report.overallStatus !== "ok" || report.repairs.length > 0) {
+            log.warn(`Self-health result: ${report.overallStatus}, ` +
+                `checks=${report.checks.length}, repairs=${report.repairs.length}`);
+        }
+        return report;
+    }
+    checkConfig() {
+        try {
+            const runtime = getFridayNextRuntime();
+            if (!runtime?.config) {
+                return { name: "config", status: "failed", detail: "Runtime config loader not available" };
+            }
+            const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(runtime.config));
+            if (!cfg.authToken) {
+                return { name: "config", status: "degraded", detail: "authToken is empty; all requests will 401" };
+            }
+            return { name: "config", status: "ok", detail: "Config resolved with authToken" };
+        }
+        catch (err) {
+            return {
+                name: "config",
+                status: "failed",
+                detail: `Config resolution error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    checkSseEmitter() {
+        try {
+            const connCount = sseEmitter.getConnectionCount();
+            return {
+                name: "sseEmitter",
+                status: "ok",
+                detail: `Active connections: ${connCount}`,
+            };
+        }
+        catch (err) {
+            return {
+                name: "sseEmitter",
+                status: "failed",
+                detail: `Emitter check error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    checkActiveRuns() {
+        try {
+            const count = getActiveRunCount();
+            return {
+                name: "activeRuns",
+                status: "ok",
+                detail: `Active runs: ${count}`,
+            };
+        }
+        catch (err) {
+            return {
+                name: "activeRuns",
+                status: "failed",
+                detail: `Active runs check error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    async repairConfig() {
+        try {
+            const runtime = getFridayNextRuntime();
+            if (!runtime?.config) {
+                return {
+                    component: "config",
+                    action: "re-resolve config",
+                    result: "failed",
+                    detail: "Runtime config loader not available",
+                };
+            }
+            resolveFridayNextConfig(getHostOpenClawConfigSnapshot(runtime.config));
+            return { component: "config", action: "re-resolve config", result: "ok", detail: "Config re-resolved" };
+        }
+        catch (err) {
+            return {
+                component: "config",
+                action: "re-resolve config",
+                result: "failed",
+                detail: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async repairSseEmitter() {
+        return {
+            component: "sseEmitter",
+            action: "verify emitter",
+            result: "ok",
+            detail: "SSE emitter singleton is accessible",
+        };
+    }
+}
+let healthCheckRunner = null;
+export function getHealthCheckRunner() {
+    if (!healthCheckRunner) {
+        healthCheckRunner = new HealthCheckRunner();
+    }
+    return healthCheckRunner;
+}
+export function resetHealthCheckRunnerForTest() {
+    if (healthCheckRunner) {
+        healthCheckRunner.stop();
+        healthCheckRunner = null;
+    }
+}

package/dist/src/http/handlers/health.d.ts

@@ -0,0 +1,23 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface HealthComponentStatus {
+    status: "ok" | "degraded" | "failed" | "pending" | "not_found";
+    detail: string;
+    [key: string]: unknown;
+}
+interface RepairAction {
+    component: string;
+    action: string;
+    result: "ok" | "failed";
+    detail: string;
+}
+export interface HealthCheckResult {
+    ok: boolean;
+    timestamp: number;
+    deviceId: string;
+    nodeDeviceId: string;
+    devicePairing?: HealthComponentStatus;
+    nodePairing?: HealthComponentStatus;
+    repairActions?: RepairAction[];
+}
+export declare function handleHealth(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+export {};