@ozaiya/openclaw-channel 0.10.24 → 0.10.25

package/dist/index.d.ts

@@ -12,7 +12,7 @@ declare const plugin: {
     description: string;
     configSchema: {
         readonly type: "object";
-        readonly additionalProperties: false;
+        readonly additionalProperties: true;
         readonly properties: {
             readonly enabled: {
                 readonly type: "boolean";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { ozaiyaPlugin } from "./src/channel.js";
+import { ozaiyaPlugin, recordNativeToolStart, recordNativeToolEnd, recordLlmUsage } from "./src/channel.js";
 import { ozaiyaPluginConfigSchema } from "./src/configSchema.js";
 import { setOzaiyaRuntime } from "./src/runtime.js";
 const plugin = {
@@ -9,6 +9,26 @@ const plugin = {
     register(api) {
         setOzaiyaRuntime(api.runtime);
         api.registerChannel({ plugin: ozaiyaPlugin });
+        // Observe OpenClaw's NATIVE tool calls (browser/shell/file/etc.) so the task
+        // step-timeline + per-task usage have data for agents that work through
+        // OpenClaw's own tools rather than the channel's text tools. Best-effort and
+        // optional: older gateways without the hook API simply skip this.
+        try {
+            api.on?.("before_tool_call", (event, hookCtx) => {
+                recordNativeToolStart(event?.toolName, hookCtx?.sessionKey, hookCtx?.agentId);
+            });
+            api.on?.("after_tool_call", (event, hookCtx) => {
+                recordNativeToolEnd(event?.toolName, !event?.error, hookCtx?.sessionKey, hookCtx?.agentId, event?.durationMs);
+            });
+            // Accumulate per-task LLM token usage so the Records tab + in-chat card can
+            // show input/output token counts alongside the activity chips.
+            api.on?.("llm_output", (event, hookCtx) => {
+                recordLlmUsage(event?.usage, hookCtx?.sessionKey, hookCtx?.agentId);
+            });
+        }
+        catch {
+            /* hook API not available on this gateway version — native steps unavailable */
+        }
     },
 };
 export default plugin;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,MAAM,GAAG;IACb,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,0CAA0C;IACvD,YAAY,EAAE,wBAAwB;IACtC,QAAQ,CAAC,GAAsB;QAC7B,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC9B,GAAG,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAChD,CAAC;CACF,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC5G,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,MAAM,GAAG;IACb,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,0CAA0C;IACvD,YAAY,EAAE,wBAAwB;IACtC,QAAQ,CAAC,GAAsB;QAC7B,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC9B,GAAG,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;QAE9C,6EAA6E;QAC7E,wEAAwE;QACxE,6EAA6E;QAC7E,kEAAkE;QAClE,IAAI,CAAC;YACH,GAAG,CAAC,EAAE,EAAE,CAAC,kBAAkB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;gBAC9C,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAChF,CAAC,CAAC,CAAC;YACH,GAAG,CAAC,EAAE,EAAE,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;gBAC7C,mBAAmB,CACjB,KAAK,EAAE,QAAQ,EACf,CAAC,KAAK,EAAE,KAAK,EACb,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,UAAU,CAClB,CAAC;YACJ,CAAC,CAAC,CAAC;YACH,4EAA4E;YAC5E,+DAA+D;YAC/D,GAAG,CAAC,EAAE,EAAE,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;gBACxC,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YACtE,CAAC,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,+EAA+E;QACjF,CAAC;IACH,CAAC;CACF,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/src/channel.d.ts

@@ -1,3 +1,31 @@
 import type { ChannelPlugin } from "openclaw/plugin-sdk";
 import type { ResolvedOzaiyaAccount } from "./types.js";
+/**
+ * Record the START of an OpenClaw NATIVE tool call (browser/shell/file/etc.) as a
+ * task step, so the step timeline + per-task usage have data for agents that work
+ * through OpenClaw's own tools (not the channel's text tools). Called from the
+ * `before_tool_call` plugin hook. No-op when the tool is a channel tool (already
+ * tracked) or no live dispatch matches.
+ */
+export declare function recordNativeToolStart(toolName: string | undefined, sessionKey?: string, agentId?: string): void;
+/**
+ * Record the END of an OpenClaw native tool call. Called from `after_tool_call`.
+ * If no matching in-progress step exists (e.g. the `before` hook was missed), a
+ * completed step is synthesized from `durationMs` so the timeline stays correct.
+ */
+export declare function recordNativeToolEnd(toolName: string | undefined, success: boolean, sessionKey?: string, agentId?: string, durationMs?: number): void;
+/**
+ * Accumulate LLM token usage onto the live dispatch. Called from the `llm_output`
+ * plugin hook after each model call. Input-side tokens (fresh input + cache read +
+ * cache write — all billed as input) and output tokens are summed across the task so
+ * the Records tab + in-chat card can show per-task token usage. Best-effort: no-op
+ * when no live dispatch matches the session (mirrors the native-tool hooks).
+ */
+export declare function recordLlmUsage(usage: {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+} | undefined, sessionKey?: string, agentId?: string): void;
 export declare const ozaiyaPlugin: ChannelPlugin<ResolvedOzaiyaAccount>;

package/dist/src/channel.js

@@ -122,6 +122,8 @@ function buildTaskProgressContent(dispatch, completed) {
             screenId: dispatch.screenId,
             startedAt: dispatch.startedAt,
             endedAt: completed ? Date.now() : undefined,
+            tokensInput: dispatch.tokensInput,
+            tokensOutput: dispatch.tokensOutput,
         },
     };
 }
@@ -165,8 +167,286 @@ function onToolCallComplete(dispatch, toolName, success) {
     }
     sendOrEditProgressMessage(dispatch, false).catch(() => { });
 }
+// Channel tools (the text-fallback set) are already step-tracked by the execute
+// wrapper; the native-tool hook skips these names so they aren't double-counted.
+const KNOWN_CHANNEL_TOOLS = new Set();
+// Debounced progress-card edit. Native browsing can fire many tool calls in quick
+// succession; without this we'd edit the chat message dozens of times. The step is
+// recorded synchronously regardless — only the visible card update is coalesced.
+function scheduleProgressUpdate(dispatch) {
+    if (dispatch.progressTimer)
+        return;
+    dispatch.progressTimer = setTimeout(() => {
+        dispatch.progressTimer = undefined;
+        sendOrEditProgressMessage(dispatch, false).catch(() => { });
+    }, 1000);
+}
+/** A short, single-line title for a task, derived from the user's prompt. */
+function deriveTaskTitle(text) {
+    if (!text)
+        return undefined;
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    if (!oneLine)
+        return undefined;
+    return oneLine.length > 60 ? `${oneLine.slice(0, 57)}…` : oneLine;
+}
+/** Find the live dispatch a native-tool hook belongs to (by session, then agent). */
+function findActiveDispatchBySession(sessionKey, agentId) {
+    if (!sessionKey && !agentId)
+        return undefined;
+    for (const d of activeDispatches.values()) {
+        if (sessionKey && d.sessionKey === sessionKey)
+            return d;
+    }
+    for (const d of activeDispatches.values()) {
+        if (agentId && d.agentId === agentId)
+            return d;
+    }
+    return undefined;
+}
+/**
+ * Record the START of an OpenClaw NATIVE tool call (browser/shell/file/etc.) as a
+ * task step, so the step timeline + per-task usage have data for agents that work
+ * through OpenClaw's own tools (not the channel's text tools). Called from the
+ * `before_tool_call` plugin hook. No-op when the tool is a channel tool (already
+ * tracked) or no live dispatch matches.
+ */
+export function recordNativeToolStart(toolName, sessionKey, agentId) {
+    if (!toolName || KNOWN_CHANNEL_TOOLS.has(toolName))
+        return;
+    const dispatch = findActiveDispatchBySession(sessionKey, agentId);
+    if (!dispatch)
+        return;
+    onToolCallStart(dispatch, toolName, toolName);
+    // onToolCallStart edits immediately; for chatty native tools, debounce instead.
+    if (dispatch.progressTimer) {
+        clearTimeout(dispatch.progressTimer);
+        dispatch.progressTimer = undefined;
+    }
+}
+/**
+ * Record the END of an OpenClaw native tool call. Called from `after_tool_call`.
+ * If no matching in-progress step exists (e.g. the `before` hook was missed), a
+ * completed step is synthesized from `durationMs` so the timeline stays correct.
+ */
+export function recordNativeToolEnd(toolName, success, sessionKey, agentId, durationMs) {
+    if (!toolName || KNOWN_CHANNEL_TOOLS.has(toolName))
+        return;
+    const dispatch = findActiveDispatchBySession(sessionKey, agentId);
+    if (!dispatch)
+        return;
+    const step = dispatch.steps.find((s) => s.toolName === toolName && s.status === "in_progress");
+    if (step) {
+        step.status = success ? "completed" : "failed";
+        step.completedAt = Date.now();
+    }
+    else {
+        const end = Date.now();
+        dispatch.steps.push({
+            toolName,
+            label: toolName,
+            status: success ? "completed" : "failed",
+            category: categorize(toolName),
+            startedAt: durationMs != null ? Math.max(0, end - durationMs) : end,
+            completedAt: end,
+        });
+    }
+    if (dispatch.currentTool === toolName) {
+        dispatch.currentTool = undefined;
+        dispatch.currentLabel = undefined;
+        dispatch.currentCategory = undefined;
+    }
+    scheduleProgressUpdate(dispatch);
+}
+/**
+ * Accumulate LLM token usage onto the live dispatch. Called from the `llm_output`
+ * plugin hook after each model call. Input-side tokens (fresh input + cache read +
+ * cache write — all billed as input) and output tokens are summed across the task so
+ * the Records tab + in-chat card can show per-task token usage. Best-effort: no-op
+ * when no live dispatch matches the session (mirrors the native-tool hooks).
+ */
+export function recordLlmUsage(usage, sessionKey, agentId) {
+    if (!usage)
+        return;
+    const dispatch = findActiveDispatchBySession(sessionKey, agentId);
+    if (!dispatch)
+        return;
+    const input = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+    const output = usage.output ?? 0;
+    if (input)
+        dispatch.tokensInput = (dispatch.tokensInput ?? 0) + input;
+    if (output)
+        dispatch.tokensOutput = (dispatch.tokensOutput ?? 0) + output;
+}
+/**
+ * Pull the largest GitHub-flavored markdown table out of `text` as rows of cells,
+ * dropping the `---|---` separator row. Returns null when there's no real table
+ * (needs a header + separator + at least one body row).
+ */
+function extractMarkdownTable(text) {
+    const lines = text.split(/\r?\n/);
+    let best = null;
+    let cur = [];
+    const flush = () => {
+        if (cur.length >= 3 && (!best || cur.length > best.length))
+            best = cur;
+        cur = [];
+    };
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (line.startsWith("|") && line.endsWith("|") && line.length > 2) {
+            cur.push(line.slice(1, -1).split("|").map((c) => c.trim()));
+        }
+        else {
+            flush();
+        }
+    }
+    flush();
+    if (!best)
+        return null;
+    return best.filter((row) => !row.every((c) => /^:?-+:?$/.test(c) || c === ""));
+}
+/**
+ * Fallback table extractor for the bullet-list format these agents actually emit
+ * (e.g. section headers like "机械键盘" / "显示器" followed by `- 型号：价格` lines).
+ * Produces [分类, 型号, 价格] rows (or [项目, 价格] when there are no sections).
+ */
+function extractBulletTable(text) {
+    const lines = text.split(/\r?\n/);
+    const rows = [];
+    let section = "";
+    let usedSection = false;
+    // Accept the many bullet glyphs models emit (hyphen, en/em dash, •·●▪◦‣*, digits like "1.").
+    const bulletRe = /^(?:[-*•·●▪◦‣–—‐]|\d+[.)])\s*(.+?)\s*[:：]\s*(.+?)\s*$/;
+    const strip = (s) => s.replace(/\*\*/g, "").replace(/`/g, "").trim();
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        const m = bulletRe.exec(line);
+        if (m) {
+            const name = strip(m[1]);
+            const value = strip(m[2]);
+            if (name && value) {
+                if (section) {
+                    rows.push([section, name, value]);
+                    usedSection = true;
+                }
+                else
+                    rows.push([name, value]);
+            }
+        }
+        else if (!/^(?:[-*•·●▪◦‣–—‐]|\d+[.)])/.test(line)
+            && line.length <= 24
+            && !line.includes(":") && !line.includes("：")
+            && !/[。.!?！？；;,，]$/.test(line)) {
+            // A short, punctuation-free standalone line is a section header.
+            section = strip(line);
+        }
+    }
+    if (rows.length < 2)
+        return null;
+    if (usedSection) {
+        const norm = rows.map((r) => (r.length === 3 ? r : ["", r[0], r[1]]));
+        return [["分类", "型号/项目", "价格/信息"], ...norm];
+    }
+    return [["项目", "信息"], ...rows];
+}
+/** Serialize table rows to RFC-4180 CSV. */
+function rowsToCsv(rows) {
+    return rows
+        .map((r) => r.map((c) => {
+        const v = c.replace(/<br\s*\/?>/gi, " ").trim();
+        return /[",\n]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v;
+    }).join(","))
+        .join("\n");
+}
+/**
+ * Deliverable safety net + format guarantee. Two jobs:
+ *  1. If the model published NOTHING for a deliverable request, recover the table
+ *     (markdown or the bullet-list format agents emit) from the chat reply.
+ *  2. **Excel guarantee** — when the user asked for a 表格/spreadsheet but the model
+ *     published a NON-spreadsheet file (e.g. HTML), additionally produce a `.csv`
+ *     (Excel-openable) from the reply, so a "表格" request always yields a CSV.
+ * Plain prose asks ("报告/文档") fall back to a markdown report only when nothing
+ * was published. Best-effort throughout.
+ */
+async function maybeAutoPublishDeliverable(dispatch, account, groupId, ctx) {
+    const title = dispatch.title ?? "";
+    const ask = title.toLowerCase();
+    // A tabular/spreadsheet ask — these MUST end up as a CSV the user can open in Excel.
+    const wantsSpreadsheet = /(表格|清单|列表|电子表格|导出|数据)/.test(title)
+        || /(excel|csv|xlsx|spreadsheet)/.test(ask);
+    const wantsDeliverable = wantsSpreadsheet
+        || /(报告|report|文档|document|文件|\bfile\b|\btable\b|export)/.test(ask)
+        || /报告/.test(title);
+    if (!wantsDeliverable)
+        return;
+    const have = dispatch.deliverables ?? [];
+    const haveSpreadsheet = have.some((d) => /csv|spreadsheet|ms-excel|excel/i.test(d.mime ?? "") || /\.(csv|xlsx?|xls)$/i.test(d.name ?? ""));
+    // Already delivered an Excel-openable file → done.
+    if (haveSpreadsheet)
+        return;
+    // A non-spreadsheet deliverable exists AND the user didn't specifically want a
+    // spreadsheet → that deliverable already satisfies the ask. (When the user DID want
+    // a spreadsheet we fall through to add a CSV alongside the model's HTML.)
+    if (have.length > 0 && !wantsSpreadsheet)
+        return;
+    // Prefer a real markdown table, then the bullet-list format the agents actually
+    // emit. Largest extraction across all delivered chunks wins.
+    let rows = null;
+    for (const text of dispatch.replyTexts ?? []) {
+        const t = extractMarkdownTable(text) ?? extractBulletTable(text);
+        if (t && (!rows || t.length > rows.length))
+            rows = t;
+    }
+    // Markdown-report fallback only when NOTHING was published and the ask isn't a
+    // spreadsheet (a 表格 ask with no parseable table can't be forced into a CSV).
+    const longestReply = (dispatch.replyTexts ?? [])
+        .map((t) => t.trim())
+        .filter((t) => t.length >= 150)
+        .sort((a, b) => b.length - a.length)[0];
+    const makeCsv = !!rows && rows.length >= 2;
+    const makeMd = !makeCsv && have.length === 0 && !wantsSpreadsheet && !!longestReply;
+    ctx.log?.info?.(`ozaiya: auto-deliverable — wantsSpreadsheet=${wantsSpreadsheet}, have=${have.length}, rows=${rows?.length ?? 0}, csv=${makeCsv}, md=${makeMd}`);
+    if (!makeCsv && !makeMd)
+        return;
+    try {
+        const safe = (title.replace(/[^\p{L}\p{N}_-]+/gu, "_").slice(0, 40)) || "table";
+        const body = makeCsv ? `${rowsToCsv(rows)}` : longestReply; // CSV gets a UTF-8 BOM for Excel
+        const name = makeCsv ? `${safe}.csv` : `${safe}.md`;
+        const mime = makeCsv ? "text/csv" : "text/markdown";
+        const tmp = path.join(os.tmpdir(), `ozaiya-deliverable-${Date.now()}.${makeCsv ? "csv" : "md"}`);
+        await fs.writeFile(tmp, body, "utf8");
+        const file = await prepareOutboundAttachment(account, groupId, { localPath: tmp, name, mime });
+        await fs.unlink(tmp).catch(() => { });
+        const deliverable = {
+            name: title.trim() ? `${title.trim()}${makeCsv ? "（表格）" : ""}` : file.name,
+            url: file.url,
+            mime: file.mime,
+            size: file.size,
+            published: false,
+        };
+        // For a spreadsheet ask, the CSV supersedes any HTML/markdown rendering of the
+        // SAME table the model published — drop those so the user gets one Excel asset
+        // (other artifacts like images/PDF are kept).
+        const kept = (makeCsv && wantsSpreadsheet)
+            ? have.filter((d) => !/html|markdown/i.test(d.mime ?? "") && !/\.(html?|md|markdown)$/i.test(d.name ?? ""))
+            : have;
+        const dropped = have.length - kept.length;
+        dispatch.deliverables = [...kept, deliverable];
+        ctx.log?.info?.(`ozaiya: auto-published ${makeCsv ? `table CSV (${rows.length} rows)` : "markdown report"}${dropped ? ` (dropped ${dropped} non-spreadsheet deliverable${dropped > 1 ? "s" : ""})` : ""}`);
+    }
+    catch (err) {
+        ctx.log?.warn?.(`ozaiya: auto-deliverable failed: ${String(err)}`);
+    }
+}
 async function finalizeTaskProgress(dispatch) {
     const now = Date.now();
+    if (dispatch.progressTimer) {
+        clearTimeout(dispatch.progressTimer);
+        dispatch.progressTimer = undefined;
+    }
     for (const step of dispatch.steps) {
         if (step.status === "in_progress") {
             step.status = "completed";
@@ -3473,6 +3753,10 @@ ctx) {
         startedAt: Date.now(),
         screenId: "sandbox",
         recording: null,
+        sessionKey: route.sessionKey,
+        agentId: route.agentId,
+        title: deriveTaskTitle(effectiveMessageText ?? agentInput),
+        replyTexts: [],
     };
     activeDispatches.set(account.accountId, dispatch);
     // Start screen recording for replay (best-effort; null if nothing recordable).
@@ -3488,6 +3772,10 @@ ctx) {
     // Uses the current bot's account directly (not the factory which re-resolves in gateway mode).
     const channelTools = buildChannelTools(account, ctx.cfg);
     const channelToolsByName = new Map(channelTools.map((t) => [t.name, t]));
+    // Register channel tool names so the native-tool hook skips them (avoids double
+    // counting; channel tools are already tracked by their execute wrapper).
+    for (const name of channelToolsByName.keys())
+        KNOWN_CHANNEL_TOOLS.add(name);
     ctx.log?.info?.(`ozaiya: text fallback tools loaded: ${channelToolsByName.size} tools [${[...channelToolsByName.keys()].join(", ")}]`);
     // Dispatch to agent with buffered block dispatcher
     try {
@@ -3500,6 +3788,9 @@ ctx) {
                     ctx.log?.info?.(`ozaiya: deliver called, text length=${replyText?.length ?? 0}, empty=${!replyText?.trim()}, voiceReply=${voiceReply}, voiceReplyVoice=${voiceReplyVoice ?? 'none'}`);
                     if (!replyText?.trim())
                         return;
+                    // Remember delivered text so the post-dispatch deliverable safety net can
+                    // recover a table/report the model pasted inline instead of publishing.
+                    activeDispatches.get(account.accountId)?.replyTexts?.push(replyText);
                     // Generic fallback: intercept tool calls that models output as text
                     // instead of structured API tool_calls. Supports two formats:
                     // 1. JSON function syntax: tool_name({"arg":"value"}) or tool_name({arg: "value"})
@@ -3623,45 +3914,67 @@ ctx) {
         });
     }
     finally {
+        // Recover an inline table the model forgot to publish_artifact, BEFORE finalizing
+        // so the final progress card includes the deliverable.
+        await maybeAutoPublishDeliverable(dispatch, account, groupId, ctx).catch(() => { });
         await finalizeTaskProgress(dispatch);
-        // Stop + upload the screen recording, then register it for replay (all best-effort).
-        const recording = dispatch.recording;
-        if (recording) {
-            try {
+        // Register the task for replay (best-effort). Upload the screen recording if we
+        // captured one; otherwise still register a STEPS-ONLY recording so the task shows
+        // up in the bot's Records tab (and counts toward usage via task.completed). Video
+        // is a bonus, not a prerequisite — compose-mode gateways without a recording-control
+        // server can't capture video but still produce a useful step timeline.
+        try {
+            const recording = dispatch.recording;
+            // Align step offsets to the recording start when we have one, else to the
+            // dispatch start so a steps-only timeline is still correctly anchored at t=0.
+            const baselineMs = recording?.startedAt ?? dispatch.startedAt;
+            let videoUrl = "";
+            let videoPath = null;
+            let durationMs = Math.max(0, Date.now() - baselineMs);
+            if (recording) {
                 const rec = await stopAndExtractRecording(recording);
                 if (rec && rec.mp4.length > 0) {
                     const filename = `replay-${dispatch.taskId}.mp4`.replace(/[^a-zA-Z0-9_.-]/g, "_");
                     const uploaded = await uploadFile(account.apiBaseUrl, account.botToken, groupId, filename, "video/mp4", rec.mp4);
-                    const steps = dispatch.steps.map((s) => ({
-                        toolName: s.toolName,
-                        label: s.label,
-                        status: s.status,
-                        category: s.category,
-                        startMs: s.startedAt != null ? Math.max(0, s.startedAt - recording.startedAt) : null,
-                        endMs: s.completedAt != null ? Math.max(0, s.completedAt - recording.startedAt) : null,
-                    }));
-                    await fetch(`${account.apiBaseUrl}/v1/bot/task-recordings`, {
-                        method: "POST",
-                        headers: {
-                            Authorization: `Bearer ${account.botToken}`,
-                            "Content-Type": "application/json",
-                        },
-                        body: JSON.stringify({
-                            taskId: dispatch.taskId,
-                            groupId,
-                            videoUrl: uploaded.url,
-                            videoPath: uploaded.path ?? null,
-                            durationMs: rec.durationMs,
-                            recordingStartedAt: recording.startedAt,
-                            steps,
-                        }),
-                    }).catch(() => { });
+                    videoUrl = uploaded.url;
+                    videoPath = uploaded.path ?? null;
+                    durationMs = rec.durationMs;
                 }
             }
-            catch (err) {
-                ctx.log?.warn?.(`ozaiya: recording upload failed: ${String(err)}`);
+            // Only register if there's something to replay (a video or at least one step).
+            if (videoUrl || dispatch.steps.length > 0) {
+                const steps = dispatch.steps.map((s) => ({
+                    toolName: s.toolName,
+                    label: s.label,
+                    status: s.status,
+                    category: s.category,
+                    startMs: s.startedAt != null ? Math.max(0, s.startedAt - baselineMs) : null,
+                    endMs: s.completedAt != null ? Math.max(0, s.completedAt - baselineMs) : null,
+                }));
+                await fetch(`${account.apiBaseUrl}/v1/bot/task-recordings`, {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${account.botToken}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        taskId: dispatch.taskId,
+                        groupId,
+                        title: dispatch.title ?? null,
+                        videoUrl,
+                        videoPath,
+                        durationMs,
+                        recordingStartedAt: baselineMs,
+                        steps,
+                        inputTokens: dispatch.tokensInput ?? 0,
+                        outputTokens: dispatch.tokensOutput ?? 0,
+                    }),
+                }).catch(() => { });
             }
         }
+        catch (err) {
+            ctx.log?.warn?.(`ozaiya: recording upload failed: ${String(err)}`);
+        }
         activeDispatches.delete(account.accountId);
     }
 }