@syengup/friday-channel-next 0.1.2 → 0.1.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 SyengUp
+Copyright (c) 2026 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

package/dist/src/friday-session.js

@@ -420,38 +420,43 @@ export function forwardAgentEventRaw(evt) {
             }, ended.deviceId);
         }
     }
-    // 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);
+    // Build sessionUsage: store (cumulative session totals) → llm_output (per-run fallback).
+    if (isTerminalLifecycle && getFridayAgentForwardRuntime()) {
+        // Defer to let store write complete, then read cumulative totals.
+        // llm_output data is per-run; store is cumulative across rounds.
+        setTimeout(() => {
+            let data = outgoingData;
+            const storeUsage = tryReadSessionUsageFromStore(sk);
+            const llmUsage = consumeRunUsage(evt.runId);
+            const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
+            let usage;
+            if (storeUsage) {
+                // Store provides cumulative session totals. Supplement with
+                // fresher model/provider from llm_output when available.
+                usage = storeUsage;
+                if (llmUsage?.modelId)
+                    usage.modelId = llmUsage.modelId;
+                if (llmUsage?.modelProvider)
+                    usage.modelProvider = llmUsage.modelProvider;
+            }
+            else {
+                // First message in session — store not yet written, fall back
+                // to per-run llm_output + RunMetadata.
+                usage = mergeUsage(llmUsage, memUsage);
+            }
             if (usage) {
-                outgoingData = { ...outgoingData, sessionUsage: usage };
+                data = { ...outgoingData, sessionUsage: usage };
             }
-        }
-        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,
+                sk,
+                deviceIdRaw,
+                outgoingData: data,
+                isTerminalLifecycle: true,
+                subagentMeta,
+            });
+        }, 100);
+        return;
     }
     completeAgentEventForward({
         evt,

package/package.json

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

package/src/friday-session.forward-agent.test.ts

@@ -200,8 +200,20 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect("reasoningPrefixChars" in (payload.data as object)).toBe(false);
   });
 
-  it("builds sessionUsage from llm_output accumulated usage on lifecycle end", () => {
-    // Simulate llm_output hook accumulating usage across API calls.
+  it("builds sessionUsage from store (cumulative) with llm_output fallback", async () => {
+    // No store entry — falls back to llm_output per-run data.
+    setFridayAgentForwardRuntime({
+      runtime: {
+        config: { current: () => ({ session: {} }) },
+        agent: {
+          session: {
+            resolveStorePath: () => "/tmp/sessions.json",
+            loadSessionStore: vi.fn(() => ({})),
+          },
+        },
+      },
+    } as never);
+
     accumulateRunUsage(runId, { input: 100, output: 50, cacheRead: 10, total: 150 }, "my-model", "openai");
     accumulateRunUsage(runId, { input: 30, output: 10, cacheRead: 0, total: 40 }, "my-model", "openai");
 
@@ -213,15 +225,18 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
       data: { phase: "end" },
     });
 
-    // Lifecycle events are synchronous now (no file I/O wait).
+    // Deferred 100ms — not broadcast yet.
+    expect(sseEmitter.broadcastToRun).not.toHaveBeenCalled();
+    await new Promise<void>((resolve) => setTimeout(resolve, 150));
+
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
     expect(forwarded.stream).toBe("lifecycle");
     const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
     expect(sessionUsage).toBeDefined();
+    // llm_output fallback — per-run totals.
     expect(sessionUsage.modelId).toBe("my-model");
     expect(sessionUsage.modelProvider).toBe("openai");
-    // Accumulated totals across both API calls.
     expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(130);
     expect((sessionUsage.tokens as Record<string, unknown>).output).toBe(60);
     expect((sessionUsage.tokens as Record<string, unknown>).cacheRead).toBe(10);
@@ -229,50 +244,63 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect((sessionUsage.tokens as Record<string, unknown>).totalFresh).toBe(true);
   });
 
-  it("merges llm_output usage with RunMetadata for sessionUsage on lifecycle end", () => {
-    // Simulate llm_output hook.
-    accumulateRunUsage(runId, { input: 500, output: 100, cacheRead: 200, cacheWrite: 0, total: 800 }, "llm-model", "llm-provider");
-
-    // Send an agent event that populates RunMetadata (model, context window).
-    forwardAgentEventRaw({
-      runId,
-      seq: 1,
-      stream: "assistant",
-      sessionKey,
-      data: {
-        model: "agent-model",
-        provider: "agent-provider",
-        usage: { input: 999, total: 999 },
-        contextWindow: 100000,
+  it("prefers store cumulative totals over llm_output per-run data", async () => {
+    const storeKey = toSessionStoreKey(sessionKey);
+    setFridayAgentForwardRuntime({
+      runtime: {
+        config: { current: () => ({ session: {} }) },
+        agent: {
+          session: {
+            resolveStorePath: () => "/tmp/sessions.json",
+            loadSessionStore: vi.fn(() => ({
+              [storeKey]: {
+                model: "store-model",
+                modelProvider: "old-provider",
+                inputTokens: 5000,
+                outputTokens: 2000,
+                totalTokens: 99999,
+                totalTokensFresh: true,
+                contextTokens: 128000,
+                estimatedCostUsd: 0.05,
+                cacheRead: 100,
+                cacheWrite: 50,
+              },
+            })),
+          },
+        },
       },
-    });
+    } as never);
+
+    // llm_output has fresher model/provider but per-run (smaller) tokens.
+    accumulateRunUsage(runId, { input: 500, output: 100, cacheRead: 200, total: 800 }, "llm-model", "llm-provider");
 
     forwardAgentEventRaw({
       runId,
-      seq: 2,
+      seq: 1,
       stream: "lifecycle",
       sessionKey,
       data: { phase: "end" },
     });
 
-    // Assistant (1st) + lifecycle.end (2nd, synchronous).
-    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(2);
-    const lifecycleCall = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1];
-    const lifecycleData = (lifecycleCall[1] as { data: { data: Record<string, unknown> } }).data.data;
-    const sessionUsage = lifecycleData.sessionUsage as Record<string, unknown> | undefined;
+    expect(sseEmitter.broadcastToRun).not.toHaveBeenCalled();
+    await new Promise<void>((resolve) => setTimeout(resolve, 150));
+
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
+    const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
     expect(sessionUsage).toBeDefined();
-    // llm_output tokens win (authoritative per-API-call data).
-    expect(sessionUsage!.modelId).toBe("llm-model");
-    expect(sessionUsage!.modelProvider).toBe("llm-provider");
-    expect((sessionUsage!.tokens as Record<string, unknown>).input).toBe(500);
-    expect((sessionUsage!.tokens as Record<string, unknown>).output).toBe(100);
-    expect((sessionUsage!.tokens as Record<string, unknown>).cacheRead).toBe(200);
-    expect((sessionUsage!.tokens as Record<string, unknown>).total).toBe(800);
-    // Context from RunMetadata (not available from llm_output).
-    expect((sessionUsage!.context as Record<string, unknown>).windowMax).toBe(100000);
+    // Store cumulative totals win.
+    expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(5000);
+    expect((sessionUsage.tokens as Record<string, unknown>).output).toBe(2000);
+    expect((sessionUsage.tokens as Record<string, unknown>).total).toBe(99999);
+    // Model/provider from llm_output (fresher) override store.
+    expect(sessionUsage.modelId).toBe("llm-model");
+    expect(sessionUsage.modelProvider).toBe("llm-provider");
+    expect(sessionUsage.estimatedCostUsd).toBe(0.05);
+    expect((sessionUsage.context as Record<string, unknown>).windowMax).toBe(128000);
   });
 
-  it("falls back to store read when llm_output has no data (deferred)", async () => {
+  it("uses store cumulative totals when llm_output has no data", async () => {
     const storeKey = toSessionStoreKey(sessionKey);
     const store: Record<string, Record<string, unknown>> = {
       [storeKey]: {

package/src/friday-session.ts

@@ -483,38 +483,40 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
     }
   }
 
-  // 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);
+  // Build sessionUsage: store (cumulative session totals) → llm_output (per-run fallback).
+  if (isTerminalLifecycle && getFridayAgentForwardRuntime()) {
+    // Defer to let store write complete, then read cumulative totals.
+    // llm_output data is per-run; store is cumulative across rounds.
+    setTimeout(() => {
+      let data = outgoingData;
+      const storeUsage = tryReadSessionUsageFromStore(sk);
+      const llmUsage = consumeRunUsage(evt.runId);
+      const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
+      let usage: FridaySessionUsagePayload | undefined;
+      if (storeUsage) {
+        // Store provides cumulative session totals. Supplement with
+        // fresher model/provider from llm_output when available.
+        usage = storeUsage;
+        if (llmUsage?.modelId) usage.modelId = llmUsage.modelId;
+        if (llmUsage?.modelProvider) usage.modelProvider = llmUsage.modelProvider;
+      } else {
+        // First message in session — store not yet written, fall back
+        // to per-run llm_output + RunMetadata.
+        usage = mergeUsage(llmUsage, memUsage);
+      }
       if (usage) {
-        outgoingData = { ...outgoingData, sessionUsage: usage };
+        data = { ...outgoingData, sessionUsage: usage };
       }
-    } 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,
+        sk,
+        deviceIdRaw,
+        outgoingData: data,
+        isTerminalLifecycle: true,
+        subagentMeta,
+      });
+    }, 100);
+    return;
   }
 
   completeAgentEventForward({