@syengup/friday-channel-next 0.0.1

package/src/http/server.ts

@@ -0,0 +1,106 @@
+/**
+ * HTTP server registration for the Friday channel.
+ *
+ * Registers routes on the gateway HTTP server under the /friday-next/ path prefix.
+ * Routes are registered via the plugin API's registerHttpRoute method.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { handleMessages } from "./handlers/messages.js";
+import { handleSseStream } from "./handlers/sse.js";
+import { handleFilesUpload } from "./handlers/files-upload.js";
+import { handleFilesDownload } from "./handlers/files-download.js";
+import { handleCancel } from "./handlers/cancel.js";
+import { handleSessionsDelete } from "./handlers/sessions-delete.js";
+import { handleSessionsSettings } from "./handlers/sessions-settings.js";
+import { handleModelsList } from "./handlers/models-list.js";
+import { handleStatus } from "./handlers/status.js";
+import { applyCorsHeaders } from "./middleware/cors.js";
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+import { sseEmitter } from "../sse/emitter.js";
+
+/** Route matcher - returns the matched handler or null. */
+async function handleFridayNextRoute(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<boolean> {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const pathname = url.pathname;
+  applyCorsHeaders(res);
+  if (req.method === "OPTIONS") {
+    res.statusCode = 204;
+    res.end();
+    return true;
+  }
+
+  // Route: GET /friday-next/events?deviceId=...
+  if (req.method === "GET" && pathname === "/friday-next/events") {
+    return await handleSseStream(req, res);
+  }
+
+  // Route: POST /friday-next/messages
+  if (req.method === "POST" && pathname === "/friday-next/messages") {
+    return await handleMessages(req, res);
+  }
+
+  // Route: POST /friday-next/files (multipart upload)
+  if (req.method === "POST" && pathname === "/friday-next/files") {
+    return await handleFilesUpload(req, res);
+  }
+
+  // Route: GET /friday-next/files/:id (download)
+  if (req.method === "GET" && pathname.startsWith("/friday-next/files/")) {
+    return await handleFilesDownload(req, res);
+  }
+
+  if (req.method === "POST" && pathname === "/friday-next/cancel") {
+    return await handleCancel(req, res);
+  }
+
+  if (req.method === "DELETE" && pathname === "/friday-next/sessions") {
+    return await handleSessionsDelete(req, res);
+  }
+
+  if ((req.method === "PUT" || req.method === "GET") && pathname === "/friday-next/sessions/settings") {
+    return await handleSessionsSettings(req, res);
+  }
+
+  if (req.method === "GET" && pathname === "/friday-next/models") {
+    return await handleModelsList(req, res);
+  }
+
+  if (req.method === "GET" && pathname === "/friday-next/status") {
+    return await handleStatus(req, res);
+  }
+
+  // Not found
+  return false;
+}
+
+export function registerFridayNextHttpRoutes(api: {
+  logger: { info: (msg: string) => void; warn: (msg: string) => void };
+  registerHttpRoute: (route: {
+    path: string;
+    handler: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+    auth: string;
+    match: string;
+  }) => void;
+}): void {
+  const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+  sseEmitter.setBacklogLimit(cfg.sseBacklogPerDevice);
+  if (!cfg.authToken) {
+    api.logger.warn("friday-next authToken not configured; all requests will 401");
+  }
+
+  // Plugin handles its own auth via extractBearerToken()
+  api.registerHttpRoute({
+    path: "/friday-next",
+    handler: handleFridayNextRoute,
+    auth: "plugin",
+    match: "prefix",
+  });
+
+  api.logger.info("Friday Next channel HTTP routes registered at /friday-next/*");
+}

package/src/logging.ts

@@ -0,0 +1,27 @@
+import type { FridayNextLogLevel } from "./config.js";
+
+const levelOrder: Record<FridayNextLogLevel, number> = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+};
+
+export function createFridayNextLogger(scope: string, level: FridayNextLogLevel = "info") {
+  const base = `[friday-next:${scope}]`;
+  const enabled = (current: FridayNextLogLevel) => levelOrder[current] >= levelOrder[level];
+  return {
+    debug: (message: string) => {
+      if (enabled("debug")) console.debug(`${base} ${message}`);
+    },
+    info: (message: string) => {
+      if (enabled("info")) console.info(`${base} ${message}`);
+    },
+    warn: (message: string) => {
+      if (enabled("warn")) console.warn(`${base} ${message}`);
+    },
+    error: (message: string) => {
+      if (enabled("error")) console.error(`${base} ${message}`);
+    },
+  };
+}

package/src/openclaw.d.ts

@@ -0,0 +1,32 @@
+declare module "openclaw/plugin-sdk/agent-harness" {
+  export const abortAgentHarnessRun: (runId: string) => void;
+  export const runAgentHarness: (...args: any[]) => any;
+}
+
+declare module "openclaw/plugin-sdk/core" {
+  export const defineChannelPluginEntry: (...args: any[]) => any;
+  export const createChatChannelPlugin: (...args: any[]) => any;
+  export type ChannelPlugin = any;
+}
+
+declare module "openclaw/plugin-sdk/media-store" {
+  export const saveMediaBuffer: (...args: any[]) => any;
+}
+
+declare module "openclaw/plugin-sdk/plugin-entry" {
+  export type OpenClawPluginApi = any;
+}
+
+declare module "openclaw/plugin-sdk/plugins/types" {
+  export type PluginHookBeforeToolCallEvent = any;
+  export type PluginHookAfterToolCallEvent = any;
+  export type PluginHookToolContext = any;
+}
+
+declare module "openclaw/plugin-sdk/reply-dispatch-runtime" {
+  export const dispatchReplyWithDispatcher: (...args: any[]) => any;
+}
+
+declare module "openclaw/plugin-sdk/status-helpers" {
+  export type ChannelAccountSnapshot = any;
+}

package/src/run-metadata.ts

@@ -0,0 +1,180 @@
+type RunRoute = {
+  runId: string;
+  deviceId: string;
+  sessionKey: string;
+};
+
+export type RunMetadata = {
+  modelName?: string;
+  totalTokens?: number;
+  /** Tokens counted toward the model context window (prompt-side: input + cache read + cache write when present). */
+  contextTokensUsed?: number;
+  /** Resolved model context window limit when the runtime exposes it. */
+  contextWindowMax?: number;
+};
+
+const runRouteById = new Map<string, RunRoute>();
+const runMetadataById = new Map<string, RunMetadata>();
+const finalDeliveredRunIds = new Set<string>();
+
+/** Vitest / harness: clears per-run metadata and final-delivered flags (not routes). */
+export function resetRunMetadataForTest(): void {
+  runMetadataById.clear();
+  finalDeliveredRunIds.clear();
+}
+
+export function registerRunRoute(route: RunRoute): void {
+  if (!route.runId.trim()) return;
+  runRouteById.set(route.runId, route);
+}
+
+export function getRunRoute(runId: string): RunRoute | undefined {
+  return runRouteById.get(runId);
+}
+
+export function setRunMetadata(runId: string, metadata: RunMetadata): void {
+  if (!runId.trim()) return;
+  const existing = runMetadataById.get(runId) ?? {};
+  runMetadataById.set(runId, { ...existing, ...metadata });
+}
+
+export function getRunMetadata(runId: string): RunMetadata | undefined {
+  return runMetadataById.get(runId);
+}
+
+export function markRunFinalDelivered(runId: string): void {
+  if (!runId.trim()) return;
+  finalDeliveredRunIds.add(runId);
+}
+
+export function hasRunFinalDelivered(runId: string): boolean {
+  return finalDeliveredRunIds.has(runId);
+}
+
+function finiteNumber(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return undefined;
+}
+
+function recordValue(value: unknown): Record<string, unknown> | null {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return null;
+}
+
+function pickInputTokens(u: Record<string, unknown>): number | undefined {
+  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: Record<string, unknown>): number | undefined {
+  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: Record<string, unknown>): number | undefined {
+  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: Record<string, unknown>): number | undefined {
+  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: Record<string, unknown>): number | undefined {
+  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: Record<string, unknown>): number | undefined {
+  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: string, data: Record<string, unknown>): void {
+  if (!runId.trim()) return;
+  const next: RunMetadata = {};
+  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/src/runtime.ts

@@ -0,0 +1,14 @@
+import { createPluginRuntimeStore } from "./vendor/runtime-store.js";
+
+type FridayRuntime = {
+  config: { loadConfig: () => unknown };
+  logger?: { info?: (...args: unknown[]) => void; warn?: (...args: unknown[]) => void };
+};
+
+const { setRuntime, getRuntime, clearRuntime } = createPluginRuntimeStore<FridayRuntime>(
+  "Friday Next runtime not initialized",
+);
+
+export const setFridayNextRuntime = setRuntime;
+export const getFridayNextRuntime = getRuntime;
+export const clearFridayNextRuntime = clearRuntime;

package/src/session/session-manager.ts

@@ -0,0 +1,230 @@
+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?: string): string {
+  if (historyDir) {
+    const match = historyDir.replace(/\/+$/, "").match(/(.*\/\.openclaw)\//);
+    if (match?.[1]) return match[1];
+  }
+  return join(os.homedir(), ".openclaw");
+}
+
+export function splitModelRef(modelRef: string): { provider?: string; modelId: string } {
+  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: string): string {
+  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: string): string {
+  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: string, rawSessionKey: string): string {
+  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?: string): string {
+  const base = deriveOpenClawBaseDir(historyDir);
+  return join(base, "agents/main/sessions/sessions.json");
+}
+
+function readSessionsData(path: string): Record<string, Record<string, unknown>> | null {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as Record<string, Record<string, unknown>>;
+  } catch {
+    return null;
+  }
+}
+
+function writeSessionsData(path: string, data: Record<string, Record<string, unknown>>): void {
+  try {
+    writeFileSync(path, JSON.stringify(data, null, 2), "utf-8");
+  } catch {
+    // best-effort
+  }
+}
+
+function upsertSessionEntry(
+  data: Record<string, Record<string, unknown>>,
+  fileKey: string,
+  sessionKey: string,
+): void {
+  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: string,
+  reasoningLevel: string,
+  thinkingLevel: string,
+  historyDir?: string,
+): void {
+  setSessionSettings(sessionKey, { reasoningLevel, thinkingLevel }, historyDir);
+}
+
+export function resolveSessionsDir(historyDir?: string): string {
+  const base = deriveOpenClawBaseDir(historyDir);
+  return join(base, "agents/main/sessions");
+}
+
+export interface DeleteSessionResult {
+  sessionKey: string;
+  sessionId?: string;
+  transcriptDeleted?: boolean;
+}
+
+export function deleteFridaySession(
+  sessionKey: string,
+  historyDir?: string,
+): DeleteSessionResult {
+  const result: DeleteSessionResult = { 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 interface FridaySessionSettings {
+  reasoningLevel?: string;
+  thinkingLevel?: string;
+  modelRef?: string;
+  providerOverride?: string;
+  modelOverride?: string;
+}
+
+export function setSessionSettings(
+  sessionKey: string,
+  settings: FridaySessionSettings,
+  historyDir?: string,
+): FridaySessionSettings {
+  try {
+    const sessionsFile = resolveSessionsFilePath(historyDir);
+    const data = readSessionsData(sessionsFile);
+    if (!data) return {};
+
+    const fileKey = toSessionStoreKey(sessionKey);
+    upsertSessionEntry(data, fileKey, sessionKey);
+
+    const fieldKeys: (keyof FridaySessionSettings)[] = [
+      "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: Record<string, unknown>): FridaySessionSettings {
+  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: string,
+  historyDir?: string,
+): FridaySessionSettings {
+  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/src/session-usage-snapshot.ts

@@ -0,0 +1,80 @@
+/**
+ * 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;
+};
+
+function finiteNonNeg(n: unknown): number | undefined {
+  if (typeof n !== "number" || !Number.isFinite(n)) return undefined;
+  const t = Math.trunc(n);
+  return t >= 0 ? t : undefined;
+}
+
+function finiteCost(n: unknown): number | undefined {
+  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: Record<string, unknown>): FridaySessionUsagePayload | undefined {
+  const payload: FridaySessionUsagePayload = {};
+
+  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: NonNullable<FridaySessionUsagePayload["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: NonNullable<FridaySessionUsagePayload["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;
+}