mulmocast 2.6.20 → 2.6.22

package/lib/utils/replicate_usage.d.ts

@@ -0,0 +1,5 @@
+import type Replicate from "replicate";
+export declare const runReplicateWithMetrics: (replicate: Replicate, identifier: `${string}/${string}` | `${string}/${string}:${string}`, input: object, signal?: AbortSignal) => Promise<{
+    output: unknown;
+    predictSec?: number;
+}>;

package/lib/utils/replicate_usage.js

@@ -0,0 +1,11 @@
+// Capture Replicate's exact billed seconds (`metrics.predict_time`) via the
+// progress callback on `replicate.run()`. Avoids switching the four
+// replicate agents from `.run()` to `predictions.create()` + poll, which
+// would be a much bigger blast radius.
+export const runReplicateWithMetrics = async (replicate, identifier, input, signal) => {
+    let lastPrediction;
+    const output = await replicate.run(identifier, { input, signal }, (prediction) => {
+        lastPrediction = prediction;
+    });
+    return { output, predictSec: lastPrediction?.metrics?.predict_time };
+};

package/lib/utils/usage_callback.d.ts

@@ -0,0 +1,4 @@
+import { type CallbackFunction } from "graphai";
+import type { MulmoStudioContext } from "../types/type.js";
+import type { UsageCollectorAPI } from "../types/usage.js";
+export declare const createUsageCallback: (target: MulmoStudioContext | UsageCollectorAPI | undefined) => CallbackFunction;

package/lib/utils/usage_callback.js

@@ -0,0 +1,93 @@
+import { NodeState } from "graphai";
+// @graphai/* LLM agents (openAIAgent / geminiAgent / anthropicAgent / groqAgent)
+// return usage in the OpenAI chat-completions wire shape:
+//   { prompt_tokens, completion_tokens, total_tokens }
+// without provider/model on the usage object. We derive provider from the
+// node's agentId and model from the node's params or the spread response.
+const LLM_AGENT_TO_PROVIDER = {
+    openAIAgent: "openai",
+    geminiAgent: "google",
+    anthropicAgent: "anthropic",
+    groqAgent: "groq",
+};
+const isAgentUsage = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    const { provider, model } = value;
+    return typeof provider === "string" && typeof model === "string";
+};
+const extractLLMUsage = (log) => {
+    const provider = log.agentId ? LLM_AGENT_TO_PROVIDER[log.agentId] : undefined;
+    if (!provider)
+        return undefined;
+    const result = log.result;
+    const u = result?.usage;
+    if (!u || typeof u.prompt_tokens !== "number" || typeof u.total_tokens !== "number")
+        return undefined;
+    const pickModel = () => {
+        const fromParams = log.params?.model;
+        if (typeof fromParams === "string")
+            return fromParams;
+        if (typeof result?.model === "string")
+            return result.model;
+        return "unknown";
+    };
+    const model = pickModel();
+    return {
+        provider,
+        model,
+        inputTokens: u.prompt_tokens,
+        outputTokens: u.completion_tokens,
+        totalTokens: u.total_tokens,
+    };
+};
+const extractUsage = (log) => {
+    // 1. mulmocast AgentUsage shape (image/TTS agents in this repo).
+    if (log.result && typeof log.result === "object") {
+        const { usage } = log.result;
+        if (isAgentUsage(usage))
+            return usage;
+    }
+    // 2. @graphai/* LLM shape — derive provider/model from log metadata.
+    return extractLLMUsage(log);
+};
+const resolveCollector = (target) => {
+    if (!target)
+        return undefined;
+    // A MulmoStudioContext has the optional `usageCollector` slot; the API itself
+    // doesn't. Distinguishing on the slot name lets either form pass through.
+    if ("usageCollector" in target)
+        return target.usageCollector;
+    return target;
+};
+// GraphAI callback that pushes any agent's reported usage into the given
+// UsageCollector when the node completes successfully. No-op when the
+// collector is absent (either undefined directly or `context.usageCollector`
+// undefined), the node fails, or the result has no `usage`.
+export const createUsageCallback = (target) => {
+    return (log, isUpdate) => {
+        if (isUpdate)
+            return;
+        if (log.state !== NodeState.Completed)
+            return;
+        const collector = resolveCollector(target);
+        if (!collector)
+            return;
+        const usage = extractUsage(log);
+        if (!usage)
+            return;
+        collector.add({
+            agent: log.agentId ?? "unknown",
+            provider: usage.provider,
+            model: usage.model,
+            beatIndex: log.mapIndex,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            totalTokens: usage.totalTokens,
+            predictSec: usage.predictSec,
+            inputChars: usage.inputChars,
+            cached: false,
+            retryAttempt: log.retryCount,
+        });
+    };
+};

package/lib/utils/usage_collector.d.ts

@@ -0,0 +1,12 @@
+import type { UsageRecord, UsageCollectorAPI } from "../types/usage.js";
+export type { UsageRecord, UsageCollectorAPI } from "../types/usage.js";
+export declare class UsageCollector implements UsageCollectorAPI {
+    private readonly records;
+    add(record: Omit<UsageRecord, "timestamp"> & {
+        timestamp?: string;
+    }): void;
+    snapshot(): UsageRecord[];
+    merge(other: UsageCollectorAPI): void;
+    clear(): void;
+    get size(): number;
+}

package/lib/utils/usage_collector.js

@@ -0,0 +1,18 @@
+export class UsageCollector {
+    records = [];
+    add(record) {
+        this.records.push({ ...record, timestamp: record.timestamp ?? new Date().toISOString() });
+    }
+    snapshot() {
+        return this.records.map((record) => ({ ...record }));
+    }
+    merge(other) {
+        other.snapshot().forEach((record) => this.records.push({ ...record }));
+    }
+    clear() {
+        this.records.length = 0;
+    }
+    get size() {
+        return this.records.length;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "2.6.20",
+  "version": "2.6.22",
   "description": "",
   "type": "module",
   "main": "lib/index.node.js",
@@ -25,7 +25,7 @@
   },
   "resolutions": {
     "minimatch": "^10.2.5",
-    "tar": "7.5.15",
+    "tar": "7.5.16",
     "yauzl": "^3.3.1"
   },
   "bin": {
@@ -102,7 +102,7 @@
     "@inquirer/input": "^5.0.13",
     "@inquirer/select": "^5.1.5",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@modernized/fluent-ffmpeg": "^1.0.0",
+    "@modernized/fluent-ffmpeg": "^1.0.1",
     "@mozilla/readability": "^0.6.0",
     "@mulmocast/deck": "^1.1.0",
     "@tavily/core": "^0.7.3",
@@ -127,16 +127,16 @@
     "@types/jsdom": "^28.0.3",
     "@types/yargs": "^17.0.35",
     "cross-env": "^10.1.0",
-    "eslint": "^10.4.1",
+    "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-sonarjs": "^4.0.3",
     "globals": "^17.6.0",
-    "prettier": "^3.8.3",
+    "prettier": "^3.8.4",
     "tsx": "^4.22.4",
     "typescript": "6.0.3",
-    "typescript-eslint": "^8.60.1"
+    "typescript-eslint": "^8.61.1"
   },
   "engines": {
     "node": ">=22.0.0"