@lightcone-ai/daemon 0.14.0 → 0.14.1

package/mcp-servers/official/video-narration-planner/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { pathToFileURL } from 'url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+import { detailSections, planVideo } from './core.js';
+
+function isExecutedDirectly(metaUrl) {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return pathToFileURL(entry).href === metaUrl;
+  } catch {
+    return false;
+  }
+}
+
+function toTextContent(payload) {
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(payload, null, 2),
+    }],
+  };
+}
+
+function toErrorContent(error) {
+  return {
+    isError: true,
+    content: [{
+      type: 'text',
+      text: `Error: ${error.message}`,
+    }],
+  };
+}
+
+export function createVideoNarrationPlannerServer({
+  env = process.env,
+  fetchFn = globalThis.fetch,
+} = {}) {
+  const server = new McpServer({ name: 'official-video-narration-planner', version: '0.1.0' });
+
+  server.tool(
+    'plan_video',
+    'Stage 2: plan narrative arc + phase plan for URL narration video. Enforces highlights<=3 and phases<=5.',
+    {
+      understanding: z.record(z.any()).describe('Stage 1 output page_understanding object.'),
+      persona: z.string().optional().describe('Target audience/persona description.'),
+      target_platform: z.string().describe('Target platform: 小红书/xiaohongshu, 抖音/douyin, 视频号/wechat_video.'),
+      total_duration_s: z.number().int().min(20).max(90).optional().describe('Optional explicit target duration in seconds.'),
+    },
+    async (args) => {
+      try {
+        const payload = planVideo(args ?? {});
+        return toTextContent(payload);
+      } catch (error) {
+        return toErrorContent(error);
+      }
+    }
+  );
+
+  server.tool(
+    'detail_sections',
+    'Stage 3: expand each phase into sentence+voice settings, call TTS voiceover, and fill duration/dwell.',
+    {
+      strategy: z.record(z.any()).describe('Output of plan_video (video strategy with phase_plan).'),
+      workspace_id: z.string().optional().describe('Workspace id for TTS generation. Defaults to WORKSPACE_ID env if provided.'),
+      credential_id: z.string().optional().describe('Optional explicit tts_provider credential id.'),
+      format: z.enum(['mp3', 'wav', 'flac']).optional().describe('Desired audio format for generated voiceover.'),
+      strict_tts: z.boolean().optional().describe('When true, fail if any TTS call fails; when false, fallback to estimated durations.'),
+    },
+    async (args) => {
+      try {
+        const payload = await detailSections(args ?? {}, { env, fetchFn });
+        return toTextContent(payload);
+      } catch (error) {
+        return toErrorContent(error);
+      }
+    }
+  );
+
+  return { server };
+}
+
+export async function startVideoNarrationPlannerServer(options = {}) {
+  const { server } = createVideoNarrationPlannerServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[video-narration-planner] MCP server started');
+}
+
+if (isExecutedDirectly(import.meta.url)) {
+  startVideoNarrationPlannerServer().catch((error) => {
+    console.error(`[video-narration-planner] failed to start: ${error.message}`);
+    process.exitCode = 1;
+  });
+}

package/mcp-servers/official/video-narration-planner/manifest.json

@@ -0,0 +1,30 @@
+{
+  "id": "video-narration-planner",
+  "name": "Official Video Narration Planner MCP",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "plan_video", "classification": "cacheable" },
+    { "name": "detail_sections", "classification": "mandatory" }
+  ],
+  "smoke_test": {
+    "tool": "plan_video",
+    "arguments": {
+      "understanding": {
+        "url": "https://example.com/job-detail",
+        "core_message": "岗位职责与薪资透明，适合应届生快速判断是否投递",
+        "visual_hotspots": [
+          { "id": "hero", "y_range": [120, 320], "weight": 10, "text_excerpt": "岗位标题与薪资" },
+          { "id": "requirements", "y_range": [780, 1080], "weight": 8, "text_excerpt": "学历与经验要求" },
+          { "id": "apply", "y_range": [1420, 1660], "weight": 7, "text_excerpt": "投递入口" }
+        ],
+        "skip_zones": [
+          { "y_range": [2300, 3200], "reason": "广告与推荐位" }
+        ]
+      },
+      "persona": "校招求职学生",
+      "target_platform": "douyin"
+    }
+  }
+}

package/mcp-servers/sophon-data/index.js

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { pathToFileURL } from 'url';
+
+const SERVER_NAME = 'sophon-data';
+const SERVER_VERSION = '0.1.0';
+const DEFAULT_TIMEOUT_MS = 10000;
+const MAX_HTTP_ERROR_TEXT = 400;
+
+function isExecutedDirectly(metaUrl) {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return pathToFileURL(entry).href === metaUrl;
+  } catch {
+    return false;
+  }
+}
+
+function clampInt(value, min, max, fallback) {
+  const numberValue = Number(value);
+  if (!Number.isFinite(numberValue)) return fallback;
+  const truncated = Math.trunc(numberValue);
+  if (truncated < min) return min;
+  if (truncated > max) return max;
+  return truncated;
+}
+
+function normalizeOptionalString(value) {
+  if (value == null) return undefined;
+  const normalized = String(value).trim();
+  return normalized ? normalized : undefined;
+}
+
+function parseMaybeJson(value) {
+  if (!value || typeof value !== 'string') return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function toJsonTextContent(payload) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+  };
+}
+
+class SophonMcpError extends Error {
+  constructor({ code, message, retriable, httpStatus }) {
+    super(message);
+    this.name = 'SophonMcpError';
+    this.code = code;
+    this.retriable = Boolean(retriable);
+    this.httpStatus = Number.isFinite(httpStatus) ? Number(httpStatus) : 0;
+  }
+}
+
+function toNormalizedErrorPayload(error) {
+  if (error instanceof SophonMcpError) {
+    return {
+      code: error.code,
+      message: error.message,
+      retriable: error.retriable,
+      http_status: error.httpStatus,
+    };
+  }
+
+  if (error?.name === 'AbortError') {
+    return {
+      code: 'request_timeout',
+      message: 'request timed out when calling sophon-cub',
+      retriable: true,
+      http_status: 504,
+    };
+  }
+
+  return {
+    code: 'upstream_unavailable',
+    message: String(error?.message ?? 'failed to call sophon-cub'),
+    retriable: true,
+    http_status: 0,
+  };
+}
+
+function toMcpErrorResult(error) {
+  return {
+    isError: true,
+    content: [{ type: 'text', text: JSON.stringify(toNormalizedErrorPayload(error), null, 2) }],
+  };
+}
+
+function defaultErrorByStatus(status) {
+  if (status === 400 || status === 422) {
+    return { code: 'invalid_request', retriable: false };
+  }
+  if (status === 401) {
+    return { code: 'unauthorized', retriable: false };
+  }
+  if (status === 404) {
+    return { code: 'not_found', retriable: false };
+  }
+  if (status === 503) {
+    return { code: 'service_unavailable', retriable: true };
+  }
+  if (status >= 500) {
+    return { code: 'internal_error', retriable: true };
+  }
+  return { code: 'http_error', retriable: false };
+}
+
+function buildHttpError({ status, responseBody, responseText }) {
+  const bodyCode = normalizeOptionalString(responseBody?.error?.code);
+  const bodyMessage = normalizeOptionalString(responseBody?.error?.message);
+  const textMessage = normalizeOptionalString(responseText)
+    ? String(responseText).replace(/\s+/g, ' ').slice(0, MAX_HTTP_ERROR_TEXT)
+    : '';
+
+  const fallback = defaultErrorByStatus(status);
+
+  return new SophonMcpError({
+    code: bodyCode ?? fallback.code,
+    message: bodyMessage ?? textMessage ?? `sophon-cub returned HTTP ${status}`,
+    retriable: fallback.retriable,
+    httpStatus: status,
+  });
+}
+
+function normalizeBaseUrl(rawBaseUrl) {
+  const normalized = normalizeOptionalString(rawBaseUrl);
+  if (!normalized) {
+    throw new SophonMcpError({
+      code: 'invalid_config',
+      message: 'SOPHON_API_BASE_URL is required',
+      retriable: false,
+      httpStatus: 0,
+    });
+  }
+  const trimmed = normalized.replace(/\/+$/, '');
+  let validated;
+  try {
+    validated = new URL(trimmed);
+  } catch {
+    throw new SophonMcpError({
+      code: 'invalid_config',
+      message: 'SOPHON_API_BASE_URL must be a valid URL',
+      retriable: false,
+      httpStatus: 0,
+    });
+  }
+
+  if (!validated.protocol || !validated.hostname) {
+    throw new SophonMcpError({
+      code: 'invalid_config',
+      message: 'SOPHON_API_BASE_URL must include protocol and host',
+      retriable: false,
+      httpStatus: 0,
+    });
+  }
+
+  return trimmed;
+}
+
+function buildQueryParams(query = {}) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value == null) continue;
+    if (typeof value === 'string') {
+      const normalized = normalizeOptionalString(value);
+      if (!normalized) continue;
+      params.set(key, normalized);
+      continue;
+    }
+    if (typeof value === 'boolean') {
+      params.set(key, value ? 'true' : 'false');
+      continue;
+    }
+    if (typeof value === 'number') {
+      if (!Number.isFinite(value)) continue;
+      params.set(key, String(value));
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  return params;
+}
+
+export function createSophonApiClient({
+  env = process.env,
+  fetchFn = globalThis.fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  if (typeof fetchFn !== 'function') {
+    throw new SophonMcpError({
+      code: 'invalid_config',
+      message: 'fetch API is unavailable in current runtime',
+      retriable: false,
+      httpStatus: 0,
+    });
+  }
+
+  const baseUrl = normalizeBaseUrl(env.SOPHON_API_BASE_URL);
+  const token = normalizeOptionalString(env.SOPHON_API_TOKEN);
+  if (!token) {
+    throw new SophonMcpError({
+      code: 'invalid_config',
+      message: 'SOPHON_API_TOKEN is required',
+      retriable: false,
+      httpStatus: 0,
+    });
+  }
+
+  async function requestJson({ path, query = {}, method = 'GET' }) {
+    const url = new URL(path, `${baseUrl}/`);
+    const params = buildQueryParams(query);
+    for (const [key, value] of params.entries()) {
+      url.searchParams.set(key, value);
+    }
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchFn(url, {
+        method,
+        headers: {
+          Accept: 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+        signal: controller.signal,
+      });
+
+      const responseText = await response.text();
+      const responseBody = parseMaybeJson(responseText);
+
+      if (!response.ok) {
+        throw buildHttpError({
+          status: response.status,
+          responseBody,
+          responseText,
+        });
+      }
+
+      if (!responseText.trim()) {
+        return {};
+      }
+
+      if (responseBody === null) {
+        throw new SophonMcpError({
+          code: 'invalid_response',
+          message: `sophon-cub returned non-JSON payload for ${url.pathname}`,
+          retriable: false,
+          httpStatus: response.status,
+        });
+      }
+
+      return responseBody;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  return { requestJson };
+}
+
+function normalizeCursor(value) {
+  return normalizeOptionalString(value) ?? null;
+}
+
+export function createSophonToolHandlers({ apiClient, logger = console.error } = {}) {
+  if (!apiClient || typeof apiClient.requestJson !== 'function') {
+    throw new SophonMcpError({
+      code: 'invalid_config',
+      message: 'apiClient.requestJson is required',
+      retriable: false,
+      httpStatus: 0,
+    });
+  }
+
+  return {
+    async sophon_list_sources({ kind, enabled, limit, cursor }) {
+      try {
+        const payload = await apiClient.requestJson({
+          path: '/sources',
+          query: {
+            kind,
+            enabled,
+            limit,
+            cursor,
+          },
+        });
+        return toJsonTextContent({
+          items: Array.isArray(payload?.items) ? payload.items : [],
+          next_cursor: normalizeCursor(payload?.next_cursor),
+        });
+      } catch (error) {
+        logger(`[sophon-data] sophon_list_sources failed: ${error.message}`);
+        return toMcpErrorResult(error);
+      }
+    },
+
+    async sophon_list_timeseries({ source_id, series_key_prefix, limit }) {
+      try {
+        const payload = await apiClient.requestJson({
+          path: '/timeseries',
+          query: {
+            source_id,
+            series_key_prefix,
+            limit,
+          },
+        });
+        return toJsonTextContent({
+          items: Array.isArray(payload?.items) ? payload.items : [],
+        });
+      } catch (error) {
+        logger(`[sophon-data] sophon_list_timeseries failed: ${error.message}`);
+        return toMcpErrorResult(error);
+      }
+    },
+
+    async sophon_query_timeseries({ series_id, since, until, limit, cursor }) {
+      try {
+        const payload = await apiClient.requestJson({
+          path: `/timeseries/${encodeURIComponent(String(series_id))}/points`,
+          query: {
+            since,
+            until,
+            limit,
+            cursor,
+          },
+        });
+        return toJsonTextContent({
+          points: Array.isArray(payload?.points) ? payload.points : [],
+          next_cursor: normalizeCursor(payload?.next_cursor),
+        });
+      } catch (error) {
+        logger(`[sophon-data] sophon_query_timeseries failed: ${error.message}`);
+        return toMcpErrorResult(error);
+      }
+    },
+
+    async sophon_query_documents({ q, source_id, source_kind, since, until, language, limit, cursor }) {
+      try {
+        const payload = await apiClient.requestJson({
+          path: '/documents',
+          query: {
+            q,
+            source_id,
+            source_kind,
+            since,
+            until,
+            language,
+            limit,
+            cursor,
+          },
+        });
+        return toJsonTextContent({
+          items: Array.isArray(payload?.items) ? payload.items : [],
+          next_cursor: normalizeCursor(payload?.next_cursor),
+        });
+      } catch (error) {
+        logger(`[sophon-data] sophon_query_documents failed: ${error.message}`);
+        return toMcpErrorResult(error);
+      }
+    },
+  };
+}
+
+export function createSophonDataMcpServer({
+  env = process.env,
+  fetchFn = globalThis.fetch,
+  logger = console.error,
+} = {}) {
+  const timeoutMs = clampInt(env.SOPHON_API_TIMEOUT_MS, 1000, 60000, DEFAULT_TIMEOUT_MS);
+  const apiClient = createSophonApiClient({ env, fetchFn, timeoutMs });
+  const handlers = createSophonToolHandlers({ apiClient, logger });
+  const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION });
+
+  server.tool(
+    'sophon_list_sources',
+    'List source catalog entries from sophon-cub.',
+    {
+      kind: z.string().optional().describe('Filter by source kind, e.g. rss/news/timeseries.'),
+      enabled: z.boolean().optional().describe('Filter by source enabled flag.'),
+      limit: z.number().int().min(1).max(100).optional().describe('Maximum returned items.'),
+      cursor: z.string().optional().describe('Opaque pagination cursor from previous response.'),
+    },
+    handlers.sophon_list_sources
+  );
+
+  server.tool(
+    'sophon_list_timeseries',
+    'List timeseries metadata entries from sophon-cub.',
+    {
+      source_id: z.string().optional().describe('Filter by source id.'),
+      series_key_prefix: z.string().optional().describe('Filter by series key prefix.'),
+      limit: z.number().int().min(1).max(1000).optional().describe('Maximum returned items.'),
+    },
+    handlers.sophon_list_timeseries
+  );
+
+  server.tool(
+    'sophon_query_timeseries',
+    'Query timeseries points from sophon-cub by series and time window.',
+    {
+      series_id: z.number().int().positive().describe('Timeseries id.'),
+      since: z.string().optional().describe('ISO8601 lower bound (inclusive).'),
+      until: z.string().optional().describe('ISO8601 upper bound (inclusive).'),
+      limit: z.number().int().min(1).max(10000).optional().describe('Maximum returned points.'),
+      cursor: z.string().optional().describe('Opaque pagination cursor from previous response.'),
+    },
+    handlers.sophon_query_timeseries
+  );
+
+  server.tool(
+    'sophon_query_documents',
+    'Query document summaries from sophon-cub with filters.',
+    {
+      q: z.string().optional().describe('Full-text keyword query.'),
+      source_id: z.string().optional().describe('Filter by source id.'),
+      source_kind: z.string().optional().describe('Filter by source kind.'),
+      since: z.string().optional().describe('ISO8601 lower bound for publish/collect time.'),
+      until: z.string().optional().describe('ISO8601 upper bound for publish/collect time.'),
+      language: z.string().optional().describe('Language filter, e.g. zh/en.'),
+      limit: z.number().int().min(1).max(100).optional().describe('Maximum returned items.'),
+      cursor: z.string().optional().describe('Opaque pagination cursor from previous response.'),
+    },
+    handlers.sophon_query_documents
+  );
+
+  return { server, apiClient };
+}
+
+export async function startSophonDataMcpServer(options = {}) {
+  const { server } = createSophonDataMcpServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[sophon-data] MCP server started');
+}
+
+if (isExecutedDirectly(import.meta.url)) {
+  startSophonDataMcpServer().catch((error) => {
+    const payload = toNormalizedErrorPayload(error);
+    console.error(`[sophon-data] failed to start: ${payload.code}: ${payload.message}`);
+    process.exitCode = 1;
+  });
+}

package/mcp-servers/sophon-data/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "sophon-data",
+  "name": "Sophon Data MCP Server",
+  "version": "0.1.0",
+  "runtime": "node",
+  "entrypoint": "index.js",
+  "tool_declarations": [
+    { "name": "sophon_list_sources", "classification": "cacheable" },
+    { "name": "sophon_list_timeseries", "classification": "cacheable" },
+    { "name": "sophon_query_timeseries", "classification": "cacheable" },
+    { "name": "sophon_query_documents", "classification": "cacheable" }
+  ],
+  "smoke_test": {
+    "tool": "sophon_list_sources",
+    "arguments": {
+      "limit": 1
+    }
+  }
+}

package/package.json

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