@syengup/friday-channel-next 0.0.35 → 0.0.38

package/dist/src/run-metadata.js

@@ -0,0 +1,139 @@
+const runRouteById = new Map();
+const runMetadataById = new Map();
+const finalDeliveredRunIds = new Set();
+/** Vitest / harness: clears per-run metadata and final-delivered flags (not routes). */
+export function resetRunMetadataForTest() {
+    runMetadataById.clear();
+    finalDeliveredRunIds.clear();
+}
+export function registerRunRoute(route) {
+    if (!route.runId.trim())
+        return;
+    runRouteById.set(route.runId, route);
+}
+export function getRunRoute(runId) {
+    return runRouteById.get(runId);
+}
+export function setRunMetadata(runId, metadata) {
+    if (!runId.trim())
+        return;
+    const existing = runMetadataById.get(runId) ?? {};
+    runMetadataById.set(runId, { ...existing, ...metadata });
+}
+export function getRunMetadata(runId) {
+    return runMetadataById.get(runId);
+}
+export function markRunFinalDelivered(runId) {
+    if (!runId.trim())
+        return;
+    finalDeliveredRunIds.add(runId);
+}
+export function hasRunFinalDelivered(runId) {
+    return finalDeliveredRunIds.has(runId);
+}
+function finiteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    return undefined;
+}
+function recordValue(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function pickInputTokens(u) {
+    return (finiteNumber(u.input) ??
+        finiteNumber(u.inputTokens) ??
+        finiteNumber(u.input_tokens) ??
+        finiteNumber(u.promptTokens) ??
+        finiteNumber(u.prompt_tokens) ??
+        finiteNumber(u.prompt_n));
+}
+function pickOutputTokens(u) {
+    return (finiteNumber(u.output) ??
+        finiteNumber(u.outputTokens) ??
+        finiteNumber(u.output_tokens) ??
+        finiteNumber(u.completionTokens) ??
+        finiteNumber(u.completion_tokens) ??
+        finiteNumber(u.predicted_n));
+}
+function pickCacheRead(u) {
+    const inDet = recordValue(u.input_tokens_details);
+    const prDet = recordValue(u.prompt_tokens_details);
+    return (finiteNumber(u.cacheRead) ??
+        finiteNumber(u.cache_read) ??
+        finiteNumber(u.cache_read_input_tokens) ??
+        finiteNumber(u.cached_tokens) ??
+        (inDet ? finiteNumber(inDet.cached_tokens) : undefined) ??
+        (prDet ? finiteNumber(prDet.cached_tokens) : undefined));
+}
+function pickCacheWrite(u) {
+    return (finiteNumber(u.cacheWrite) ??
+        finiteNumber(u.cache_write) ??
+        finiteNumber(u.cache_creation_input_tokens));
+}
+/** Best-effort prompt-side context footprint from a provider usage object. */
+export function contextTokensFromUsageRecord(u) {
+    const inp = pickInputTokens(u);
+    const cr = pickCacheRead(u);
+    const cw = pickCacheWrite(u);
+    const total = finiteNumber(u.total) ?? finiteNumber(u.total_tokens) ?? finiteNumber(u.totalTokens);
+    const out = pickOutputTokens(u);
+    if (inp !== undefined || cr !== undefined || cw !== undefined) {
+        return Math.max(0, Math.floor((inp ?? 0) + (cr ?? 0) + (cw ?? 0)));
+    }
+    if (total !== undefined && out !== undefined && total >= out) {
+        return Math.max(0, Math.floor(total - out));
+    }
+    return undefined;
+}
+function pickContextWindowMaxFromData(data) {
+    const v = finiteNumber(data.contextWindow) ??
+        finiteNumber(data.context_window) ??
+        finiteNumber(data.maxContextTokens) ??
+        finiteNumber(data.max_context_tokens);
+    if (typeof v === "number" && v > 0)
+        return Math.floor(v);
+    return undefined;
+}
+export function ingestAgentEventMetadata(runId, data) {
+    if (!runId.trim())
+        return;
+    const next = {};
+    const modelName = (typeof data.modelName === "string" && data.modelName.trim()) ||
+        (typeof data.model === "string" && data.model.trim()) ||
+        undefined;
+    if (modelName)
+        next.modelName = modelName;
+    const usage = recordValue(data.usage);
+    const totalTokens = finiteNumber(data.totalTokens) ??
+        finiteNumber(data.total_tokens) ??
+        finiteNumber(usage?.totalTokens) ??
+        finiteNumber(usage?.total_tokens) ??
+        finiteNumber(usage?.total);
+    if (typeof totalTokens === "number" && totalTokens > 0) {
+        next.totalTokens = Math.floor(totalTokens);
+    }
+    const usageForContext = usage ?? data;
+    const ctxUsed = contextTokensFromUsageRecord(usageForContext);
+    if (typeof ctxUsed === "number" && ctxUsed > 0) {
+        next.contextTokensUsed = ctxUsed;
+    }
+    const ctxMax = pickContextWindowMaxFromData(data);
+    if (typeof ctxMax === "number") {
+        next.contextWindowMax = ctxMax;
+    }
+    if (!next.contextWindowMax && usage) {
+        const fromUsage = pickContextWindowMaxFromData(usage);
+        if (typeof fromUsage === "number") {
+            next.contextWindowMax = fromUsage;
+        }
+    }
+    if (next.modelName ||
+        typeof next.totalTokens === "number" ||
+        typeof next.contextTokensUsed === "number" ||
+        typeof next.contextWindowMax === "number") {
+        setRunMetadata(runId, next);
+    }
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,13 @@
+type FridayRuntime = {
+    config: {
+        loadConfig: () => unknown;
+    };
+    logger?: {
+        info?: (...args: unknown[]) => void;
+        warn?: (...args: unknown[]) => void;
+    };
+};
+export declare const setFridayNextRuntime: (next: FridayRuntime) => void;
+export declare const getFridayNextRuntime: () => FridayRuntime;
+export declare const clearFridayNextRuntime: () => void;
+export {};

package/dist/src/runtime.js

@@ -0,0 +1,5 @@
+import { createPluginRuntimeStore } from "./vendor/runtime-store.js";
+const { setRuntime, getRuntime, clearRuntime } = createPluginRuntimeStore("Friday Next runtime not initialized");
+export const setFridayNextRuntime = setRuntime;
+export const getFridayNextRuntime = getRuntime;
+export const clearFridayNextRuntime = clearRuntime;

package/dist/src/session/session-manager.d.ts

@@ -0,0 +1,22 @@
+export declare function splitModelRef(modelRef: string): {
+    provider?: string;
+    modelId: string;
+};
+export declare function toSessionStoreKey(rawSessionKey: string): string;
+export declare function ensureSessionLevels(sessionKey: string, reasoningLevel: string, thinkingLevel: string, historyDir?: string): void;
+export declare function resolveSessionsDir(historyDir?: string): string;
+export interface DeleteSessionResult {
+    sessionKey: string;
+    sessionId?: string;
+    transcriptDeleted?: boolean;
+}
+export declare function deleteFridaySession(sessionKey: string, historyDir?: string): DeleteSessionResult;
+export interface FridaySessionSettings {
+    reasoningLevel?: string;
+    thinkingLevel?: string;
+    modelRef?: string;
+    providerOverride?: string;
+    modelOverride?: string;
+}
+export declare function setSessionSettings(sessionKey: string, settings: FridaySessionSettings, historyDir?: string): FridaySessionSettings;
+export declare function getSessionSettings(sessionKey: string, historyDir?: string): FridaySessionSettings;

package/dist/src/session/session-manager.js

@@ -0,0 +1,190 @@
+import { join } from "node:path";
+import os from "node:os";
+import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+const FRIDAY_AGENT_ID = "main";
+const SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+function deriveOpenClawBaseDir(historyDir) {
+    if (historyDir) {
+        const match = historyDir.replace(/\/+$/, "").match(/(.*\/\.openclaw)\//);
+        if (match?.[1])
+            return match[1];
+    }
+    return join(os.homedir(), ".openclaw");
+}
+export function splitModelRef(modelRef) {
+    const slashIdx = modelRef.indexOf("/");
+    if (slashIdx > 0) {
+        return { provider: modelRef.slice(0, slashIdx), modelId: modelRef.slice(slashIdx + 1) };
+    }
+    return { modelId: modelRef };
+}
+export function toSessionStoreKey(rawSessionKey) {
+    const raw = rawSessionKey.trim();
+    const lowered = raw.trim().toLowerCase();
+    if (!raw || lowered === "main") {
+        return `agent:${FRIDAY_AGENT_ID}:main`;
+    }
+    const parts = lowered.split(":").filter(Boolean);
+    if (parts.length >= 3 && parts[0] === "agent") {
+        const agentId = parts[1];
+        const rest = parts.slice(2).join(":");
+        if (agentId && rest) {
+            return `agent:${agentId}:${rest}`;
+        }
+    }
+    if (lowered.startsWith("agent:")) {
+        return lowered;
+    }
+    return `agent:${FRIDAY_AGENT_ID}:${lowered}`;
+}
+function toSafeSessionId(raw) {
+    const s = raw.trim();
+    if (SESSION_ID_RE.test(s))
+        return s;
+    const slug = s
+        .replace(/[^a-z0-9._-]+/gi, "-")
+        .replace(/-+/g, "-")
+        .replace(/^[-._]+|[-._]+$/g, "");
+    const base = slug || "session";
+    const prefixed = /^[a-z0-9]/i.test(base) ? base : `s${base}`;
+    return prefixed.slice(0, 128);
+}
+function sessionIdForSessionsFile(fileKey, rawSessionKey) {
+    const candidates = [rawSessionKey.trim(), fileKey.trim()];
+    for (const c of candidates) {
+        if (SESSION_ID_RE.test(c))
+            return c;
+        if (c.startsWith(`agent:${FRIDAY_AGENT_ID}:`)) {
+            const tail = c.slice(`agent:${FRIDAY_AGENT_ID}:`.length);
+            if (SESSION_ID_RE.test(tail))
+                return tail;
+            return toSafeSessionId(tail);
+        }
+    }
+    return toSafeSessionId(rawSessionKey || fileKey);
+}
+function resolveSessionsFilePath(historyDir) {
+    const base = deriveOpenClawBaseDir(historyDir);
+    return join(base, "agents/main/sessions/sessions.json");
+}
+function readSessionsData(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeSessionsData(path, data) {
+    try {
+        writeFileSync(path, JSON.stringify(data, null, 2), "utf-8");
+    }
+    catch {
+        // best-effort
+    }
+}
+function upsertSessionEntry(data, fileKey, sessionKey) {
+    const safeSessionId = sessionIdForSessionsFile(fileKey, sessionKey);
+    if (!data[fileKey]) {
+        data[fileKey] = { sessionId: safeSessionId, updatedAt: Date.now(), systemSent: true };
+    }
+    const currentSessionId = data[fileKey]["sessionId"];
+    if (typeof currentSessionId !== "string" || !SESSION_ID_RE.test(currentSessionId)) {
+        data[fileKey]["sessionId"] = safeSessionId;
+    }
+}
+export function ensureSessionLevels(sessionKey, reasoningLevel, thinkingLevel, historyDir) {
+    setSessionSettings(sessionKey, { reasoningLevel, thinkingLevel }, historyDir);
+}
+export function resolveSessionsDir(historyDir) {
+    const base = deriveOpenClawBaseDir(historyDir);
+    return join(base, "agents/main/sessions");
+}
+export function deleteFridaySession(sessionKey, historyDir) {
+    const result = { sessionKey };
+    const sessionsFile = resolveSessionsFilePath(historyDir);
+    const data = readSessionsData(sessionsFile);
+    if (!data)
+        return result;
+    const fileKey = toSessionStoreKey(sessionKey);
+    const entry = data[fileKey];
+    if (!entry)
+        return result;
+    const sessionId = typeof entry["sessionId"] === "string" ? entry["sessionId"] : undefined;
+    const sessionFilePath = typeof entry["sessionFile"] === "string" ? entry["sessionFile"] : undefined;
+    result.sessionId = sessionId;
+    if (sessionFilePath) {
+        try {
+            unlinkSync(sessionFilePath);
+            result.transcriptDeleted = true;
+        }
+        catch { /* gone already */ }
+    }
+    if (sessionId) {
+        const dir = resolveSessionsDir(historyDir);
+        for (const suffix of [".trajectory.jsonl", ".trajectory-path.json"]) {
+            try {
+                unlinkSync(join(dir, `${sessionId}${suffix}`));
+            }
+            catch { /* optional */ }
+        }
+    }
+    delete data[fileKey];
+    writeSessionsData(sessionsFile, data);
+    return result;
+}
+export function setSessionSettings(sessionKey, settings, historyDir) {
+    try {
+        const sessionsFile = resolveSessionsFilePath(historyDir);
+        const data = readSessionsData(sessionsFile);
+        if (!data)
+            return {};
+        const fileKey = toSessionStoreKey(sessionKey);
+        upsertSessionEntry(data, fileKey, sessionKey);
+        const fieldKeys = [
+            "reasoningLevel", "thinkingLevel", "modelRef", "providerOverride", "modelOverride",
+        ];
+        let updated = false;
+        for (const key of fieldKeys) {
+            const value = settings[key];
+            if (value !== undefined && data[fileKey][key] !== value) {
+                data[fileKey][key] = value;
+                updated = true;
+            }
+        }
+        if (updated) {
+            writeSessionsData(sessionsFile, data);
+        }
+        return readSettingsFromEntry(data[fileKey]);
+    }
+    catch {
+        return {};
+    }
+}
+function readSettingsFromEntry(entry) {
+    const provider = typeof entry["providerOverride"] === "string" ? entry["providerOverride"] : undefined;
+    const model = typeof entry["modelOverride"] === "string" ? entry["modelOverride"] : undefined;
+    const storedModelRef = typeof entry["modelRef"] === "string" ? entry["modelRef"] : undefined;
+    const modelRef = storedModelRef ?? (provider && model ? `${provider}/${model}` : undefined);
+    return {
+        reasoningLevel: typeof entry["reasoningLevel"] === "string" ? entry["reasoningLevel"] : undefined,
+        thinkingLevel: typeof entry["thinkingLevel"] === "string" ? entry["thinkingLevel"] : undefined,
+        modelRef,
+    };
+}
+export function getSessionSettings(sessionKey, historyDir) {
+    try {
+        const sessionsFile = resolveSessionsFilePath(historyDir);
+        const data = readSessionsData(sessionsFile);
+        if (!data)
+            return {};
+        const fileKey = toSessionStoreKey(sessionKey);
+        const entry = data[fileKey];
+        if (!entry)
+            return {};
+        return readSettingsFromEntry(entry);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/src/session-usage-snapshot.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Stable DTO for Friday SSE `lifecycle` terminal frames (`data.sessionUsage`).
+ * Populated from OpenClaw `SessionEntry` after `persistSessionUsageUpdate`.
+ */
+export type FridaySessionUsagePayload = {
+    modelId?: string;
+    modelProvider?: string;
+    tokens?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        total?: number;
+        totalFresh?: boolean;
+    };
+    context?: {
+        windowMax?: number;
+        used?: number;
+    };
+    estimatedCostUsd?: number;
+};
+/** Build a compact snapshot from a loaded session store entry (unknown shape). */
+export declare function buildSessionUsageSnapshot(entry: Record<string, unknown>): FridaySessionUsagePayload | undefined;

package/dist/src/session-usage-snapshot.js

@@ -0,0 +1,65 @@
+/**
+ * Stable DTO for Friday SSE `lifecycle` terminal frames (`data.sessionUsage`).
+ * Populated from OpenClaw `SessionEntry` after `persistSessionUsageUpdate`.
+ */
+function finiteNonNeg(n) {
+    if (typeof n !== "number" || !Number.isFinite(n))
+        return undefined;
+    const t = Math.trunc(n);
+    return t >= 0 ? t : undefined;
+}
+function finiteCost(n) {
+    if (typeof n !== "number" || !Number.isFinite(n) || n < 0)
+        return undefined;
+    return n;
+}
+/** Build a compact snapshot from a loaded session store entry (unknown shape). */
+export function buildSessionUsageSnapshot(entry) {
+    const payload = {};
+    const modelId = typeof entry.model === "string" ? entry.model.trim() : "";
+    if (modelId)
+        payload.modelId = modelId;
+    const modelProvider = typeof entry.modelProvider === "string" ? entry.modelProvider.trim() : "";
+    if (modelProvider)
+        payload.modelProvider = modelProvider;
+    const tokens = {};
+    const input = finiteNonNeg(entry.inputTokens);
+    const output = finiteNonNeg(entry.outputTokens);
+    const cacheRead = finiteNonNeg(entry.cacheRead);
+    const cacheWrite = finiteNonNeg(entry.cacheWrite);
+    const total = finiteNonNeg(entry.totalTokens);
+    if (input !== undefined)
+        tokens.input = input;
+    if (output !== undefined)
+        tokens.output = output;
+    if (cacheRead !== undefined)
+        tokens.cacheRead = cacheRead;
+    if (cacheWrite !== undefined)
+        tokens.cacheWrite = cacheWrite;
+    if (total !== undefined)
+        tokens.total = total;
+    if (entry.totalTokensFresh === true)
+        tokens.totalFresh = true;
+    if (Object.keys(tokens).length > 0)
+        payload.tokens = tokens;
+    const context = {};
+    const windowMax = finiteNonNeg(entry.contextTokens);
+    const used = finiteNonNeg(entry.totalTokens);
+    if (windowMax !== undefined)
+        context.windowMax = windowMax;
+    if (used !== undefined)
+        context.used = used;
+    if (Object.keys(context).length > 0)
+        payload.context = context;
+    const cost = finiteCost(entry.estimatedCostUsd);
+    if (cost !== undefined)
+        payload.estimatedCostUsd = cost;
+    if (!payload.modelId &&
+        !payload.modelProvider &&
+        !payload.tokens &&
+        !payload.context &&
+        payload.estimatedCostUsd === undefined) {
+        return undefined;
+    }
+    return payload;
+}

package/dist/src/sse/emitter.d.ts

@@ -0,0 +1,59 @@
+import type { ServerResponse } from "node:http";
+export type SseEventType = "connected" | "agent" | "deliver" | "tool-hook" | "outbound" | "ping" | "subagent";
+export interface SseEvent {
+    type: SseEventType;
+    data: Record<string, unknown>;
+}
+type BacklogEntry = {
+    id: number;
+    event: SseEvent;
+};
+export declare class SseConnection {
+    readonly deviceId: string;
+    private readonly res;
+    private closed;
+    private pending;
+    private flushTimer;
+    private waitingDrain;
+    constructor(deviceId: string, res: ServerResponse);
+    send(entry: BacklogEntry | SseEvent, flushNow?: boolean): void;
+    sendRaw(line: string): void;
+    private scheduleFlush;
+    private flush;
+    close(): void;
+    get isClosed(): boolean;
+}
+declare class SseEmitterRegistry {
+    private connections;
+    private runEmitter;
+    private lastRunIdByDevice;
+    private eventSeqByDevice;
+    private backlogLimit;
+    getConnectionCount(): number;
+    setBacklogLimit(limit: number): void;
+    getBacklogLimit(): number;
+    /** Last persisted / assigned SSE id for device (for `connected.lastSeq`). */
+    latestSeqForDevice(deviceId: string): number;
+    addConnection(deviceId: string, res: ServerResponse): SseConnection;
+    /**
+     * @param expectedConn When provided, only removes if this connection is still the active one
+     * (avoids stale `req.close` after a reconnect replaced the map entry).
+     */
+    removeConnection(deviceId: string, expectedConn?: SseConnection): void;
+    getConnection(deviceId: string): SseConnection | undefined;
+    private nextEntry;
+    replayBacklog(deviceId: string, afterEventId: number): number;
+    broadcast(event: SseEvent, deviceId?: string, flushNow?: boolean): void;
+    trackDeviceForRun(deviceId: string, runId: string): void;
+    untrackRun(runId: string): void;
+    hasTrackedDevices(runId: string): boolean;
+    getDeviceIdByRunId(runId: string): string | null;
+    getSoleConnectedDeviceId(): string | null;
+    getLastRunIdForDevice(deviceId: string): string | null;
+    broadcastToRun(runId: string, event: SseEvent, flushNow?: boolean): void;
+    broadcastToolEvent(deviceId: string, runId: string, event: SseEvent, flushNow?: boolean): void;
+    /** Vitest / e2e: drop connections and in-memory seq maps (does not delete disk queue files). */
+    resetForTest(): void;
+}
+export declare const sseEmitter: SseEmitterRegistry;
+export {};