@lightcone-ai/daemon 0.15.64 → 0.15.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.64",
+  "version": "0.15.66",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -1629,6 +1629,17 @@ export class AgentManager {
     }
   }
 
+  _reportTurnUsage(connection, { agentId, workspaceId, agent, usage = null }) {
+    connection.send({
+      type: 'agent:turn_usage',
+      agentId,
+      workspaceId,
+      sessionId: agent?.sessionId ?? null,
+      runtime: agent?.runtime ?? null,
+      usage,
+    });
+  }
+
   async _postInternalActionComplete({ agentId, actionId, ok, result, error }) {
     const url = `${this.serverUrl.replace(/\/$/, '')}/internal/agent/${encodeURIComponent(agentId)}/actions/${encodeURIComponent(actionId)}/complete`;
     const res = await fetch(url, {
@@ -1985,6 +1996,7 @@ export class AgentManager {
         case 'turn_end':
           agent.kimiIdle = true;
           this._resetVisibleReplyTracking(agent);
+          this._reportTurnUsage(connection, { agentId, workspaceId, agent });
           this._emitLifecycle(connection, {
             agentId,
             workspaceId,
@@ -2077,6 +2089,7 @@ export class AgentManager {
           agent.codexVisibleTextSeen = false;
           agent.codexSendMessageUsed = false;
           this._resetVisibleReplyTracking(agent);
+          this._reportTurnUsage(connection, { agentId, workspaceId, agent, usage: evt.usage ?? null });
           this._emitLifecycle(connection, {
             agentId,
             workspaceId,
@@ -2195,6 +2208,7 @@ export class AgentManager {
       }
       this._resetVisibleReplyTracking(agent);
       console.log(`[AgentManager][${displayName}] turn done (stop_reason=${event.stop_reason ?? '?'})`);
+      this._reportTurnUsage(connection, { agentId, workspaceId, agent, usage: event.usage ?? null });
       this._emitLifecycle(connection, {
         agentId,
         workspaceId,

package/src/drivers/codex.js

@@ -306,7 +306,7 @@ export function parseCodexLine(line) {
       break;
     }
     case 'turn.completed':
-      events.push({ kind: 'turn_end' });
+      events.push({ kind: 'turn_end', usage: event.usage && typeof event.usage === 'object' ? event.usage : null });
       break;
     case 'turn.failed':
       if (event.error?.message) events.push({ kind: 'error', message: event.error.message });

package/src/mcp-config.js

@@ -62,25 +62,40 @@ function resolveSkillArg(arg, config) {
   return arg;
 }
 
+// MCP servers that talk to the lightcone server at runtime — either a full
+// server-backed MCP (mysql / publisher / platform / domain-data services) or a
+// thin-proxy (`daemon/mcp-servers/_thin-proxy/forward.js`) whose tools forward
+// to /internal/agent/:agentId/mcp/:serverId/:toolName. All of these need the
+// SERVER_URL / MACHINE_API_KEY / AGENT_ID triple injected, or the proxy throws
+// "thin-proxy missing SERVER_URL / MACHINE_API_KEY / AGENT_ID env".
+const SERVER_BACKED_MCP_SERVERS = new Set([
+  'mysql',
+  'publisher',
+  'platform',
+  'research-fetch',
+  'wechat-mp-fetch',
+  'market-data-query',
+  'company-fundamentals',
+  'industry-report',
+  'risk-metrics',
+  'compliance-check',
+  'portfolio-read',
+  'portfolio-analysis',
+  // thin-proxy MCP services migrated to the server (roadmap §4) — every one of
+  // these uses startThinProxy() and requires the SERVER_URL/MACHINE_API_KEY/AGENT_ID triple.
+  'video-narration-planner',
+  'page-understanding',
+  'platform-policy-db',
+  'keyword-research',
+  'audience-research',
+  'hook-pattern-library',
+]);
+
 function baseEnvForServer(serverKey, { serverUrl, authToken, agentId, workspaceId, workspaceDir }) {
   if (serverKey === 'workspace-migrate') {
     return { SERVER_URL: serverUrl, MACHINE_API_KEY: authToken, AGENT_ID: agentId };
   }
-  if (
-    serverKey === 'mysql'
-    || serverKey === 'publisher'
-    || serverKey === 'platform'
-    || serverKey === 'research-fetch'
-    || serverKey === 'wechat-mp-fetch'
-    || serverKey === 'market-data-query'
-    || serverKey === 'company-fundamentals'
-    || serverKey === 'industry-report'
-    || serverKey === 'risk-metrics'
-    || serverKey === 'compliance-check'
-    || serverKey === 'portfolio-read'
-    || serverKey === 'portfolio-analysis'
-    || serverKey === 'video-narration-planner'
-  ) {
+  if (SERVER_BACKED_MCP_SERVERS.has(serverKey)) {
     return {
       SERVER_URL: serverUrl,
       MACHINE_API_KEY: authToken,

package/src/tools/compose-video-v2.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import os from 'os';
+import fs from 'fs';
 import { randomUUID } from 'crypto';
 import { composeVideoV2 } from '../_vendor/video/composer-v2/index.js';
 
@@ -11,11 +12,22 @@ function toolError(text) {
   return { isError: true, content: [{ type: 'text', text }] };
 }
 
+// A real screenshot / rendered card / video frame is at least tens of KB. A
+// few-KB image is almost certainly a blank or broken capture (e.g. the page
+// hadn't finished loading when screenshotted). Composing from those produces a
+// near-blank video, so reject up front rather than emit garbage.
+const MIN_IMAGE_BYTES = 4 * 1024;
+
+function statSizeOrNull(p) {
+  try { return fs.statSync(p).size; } catch { return null; }
+}
+
 export async function runComposeVideoV2Tool({ segments, outro_paths, format, resolution, output_path, workspaceDir }) {
   if (!Array.isArray(segments) || segments.length === 0) {
     return toolError('segments must be a non-empty array.');
   }
 
+  const imagePaths = [];
   for (let i = 0; i < segments.length; i++) {
     const seg = segments[i];
     const kind = seg.visual_kind;
@@ -30,6 +42,30 @@ export async function runComposeVideoV2Tool({ segments, outro_paths, format, res
     if (kind !== 'carousel' && !seg.visual_path) {
       return toolError(`segments[${i}]: visual_path required for kind=${kind}.`);
     }
+    if (kind === 'image' && seg.visual_path) imagePaths.push(seg.visual_path);
+    if (kind === 'carousel' && Array.isArray(seg.visual_paths)) imagePaths.push(...seg.visual_paths.filter(Boolean));
+  }
+
+  // Garbage-in guard: refuse to compose from blank/broken source images.
+  for (const p of new Set(imagePaths)) {
+    const size = statSizeOrNull(p);
+    if (size === null) {
+      return toolError(`Source image not found: ${p}. Re-capture/render it before composing.`);
+    }
+    if (size < MIN_IMAGE_BYTES) {
+      return toolError(
+        `Source image ${p} is only ${size} bytes — almost certainly a blank or broken capture `
+        + `(e.g. the page hadn't finished loading when screenshotted). Re-capture with the page fully loaded, then retry.`
+      );
+    }
+  }
+  // Heuristic warning: a multi-segment image video that reuses one single image
+  // will look near-static — usually a sign the source page didn't render and the
+  // agent fell back to one blank screenshot.
+  let warning = null;
+  if (imagePaths.length >= 2 && new Set(imagePaths).size === 1) {
+    warning = `WARNING: all ${imagePaths.length} image segments reuse the same file (${imagePaths[0]}). `
+      + 'The output will be near-static — verify the source page actually rendered before submitting this video.';
   }
 
   const outDir = workspaceDir
@@ -46,13 +82,15 @@ export async function runComposeVideoV2Tool({ segments, outro_paths, format, res
       output_path: outPath,
     });
 
-    return toolText([
+    const lines = [
       'compose_video_v2 completed.',
       `path=${result.path}`,
       `duration_ms=${result.duration_ms}`,
       `segments=${segments.length}`,
       `outro_clips=${(outro_paths ?? []).length}`,
-    ].join('\n'));
+    ];
+    if (warning) lines.push(warning);
+    return toolText(lines.join('\n'));
   } catch (error) {
     return toolError(`compose_video_v2 failed: ${error.message}`);
   }

package/src/workspace-file-upload.js

@@ -20,8 +20,6 @@ const TEXT_EXTS = new Set([
   '.csv', '.xml', '.yaml', '.yml', '.sh',
 ]);
 
-const LARGE_FILE_THRESHOLD = 5 * 1024 * 1024; // 5MB
-
 export function resolveWorkspaceFileUploadPlan({ localPath, workspacePath }) {
   const target = String(workspacePath ?? '').trim() || String(localPath ?? '').trim();
   const ext = extname(target).toLowerCase();
@@ -36,9 +34,11 @@ function sha256ofBuffer(buf) {
 }
 
 /**
- * Upload a local file to the workspace via the new presign → PUT → confirm flow.
- * For large files (>= 5MB), presign returns immediately (DB status = uploading)
- * and the PUT + confirm happen in the background.
+ * Upload a local file to the workspace via the presign → PUT → confirm flow.
+ * The PUT + confirm are awaited: a fire-and-forget background upload could be
+ * abandoned when the agent run / daemon process ends, leaving the DB row stuck
+ * at object_status='uploading' forever (the file then 202s "uploading" on every
+ * read). Blocking the tool call for a few seconds is cheaper than that.
  */
 async function uploadBinaryFile({
   localPath,
@@ -64,25 +64,13 @@ async function uploadBinaryFile({
     return { mode: 'object-storage', mime, bytes: size, objectKey, deduped: true };
   }
 
-  const isLarge = size >= LARGE_FILE_THRESHOLD;
-
-  const doPut = async () => {
-    const resp = await fetch(uploadUrl, {
-      method: 'PUT',
-      body: buf,
-      headers: { 'Content-Type': mime, 'Content-Length': String(size) },
-    });
-    if (!resp.ok) throw new Error(`COS PUT failed: ${resp.status} ${await resp.text()}`);
-    await confirmUpload({ workspaceId, path: workspacePath, objectKey });
-  };
-
-  if (isLarge) {
-    // Fire-and-forget for large files; server already wrote `uploading` status
-    doPut().catch(err => console.error('[workspace-upload] large file background upload failed:', err?.message));
-    return { mode: 'object-storage', mime, bytes: size, objectKey, async: true };
-  }
-
-  await doPut();
+  const resp = await fetch(uploadUrl, {
+    method: 'PUT',
+    body: buf,
+    headers: { 'Content-Type': mime, 'Content-Length': String(size) },
+  });
+  if (!resp.ok) throw new Error(`COS PUT failed: ${resp.status} ${await resp.text()}`);
+  await confirmUpload({ workspaceId, path: workspacePath, objectKey });
   return { mode: 'object-storage', mime, bytes: size, objectKey, async: false };
 }