memind/wechat/handlers/scheduled-task.mjs

import { isPageGenerateText } from '../intent/patterns.mjs';
import {
  formatScheduledTaskCancelReply,
  formatScheduledTaskListReply,
  isScheduledTaskIntent,
  parseScheduledTaskIntent,
} from '../../scheduled-task-intent.mjs';
import { resolveScheduledTaskCancelWithLlm } from '../../wechat-scheduled-task-manage-llm.mjs';

export async function handleWechatScheduledTaskIntent({
  intent,
  user,
  scheduledTaskService,
  wechatScheduledTaskManageLlmConfigService = null,
  llmProviderService = null,
  env = process.env,
  logger = console,
}) {
  if (!scheduledTaskService) return null;

  const agentText = String(intent?.agentText ?? '').trim();
  if (isPageGenerateText(agentText)) {
    return null;
  }

  const timezone = env.H5_DEFAULT_TIMEZONE || 'Asia/Shanghai';
  const taskIntent = parseScheduledTaskIntent(agentText, {
    timezone,
  });
  if (!isScheduledTaskIntent(taskIntent)) return null;

  try {
    if (taskIntent.action === 'list_scheduled_tasks') {
      const tasks = await scheduledTaskService.listTasks({
        userId: user.userId,
        status: 'active',
        limit: 20,
      });
      return formatScheduledTaskListReply(tasks);
    }

    if (taskIntent.action === 'create_scheduled_task') {
      return null;
    }

    if (taskIntent.action === 'cancel_scheduled_task') {
      const tasks = await scheduledTaskService.listTasks({
        userId: user.userId,
        status: 'active',
        limit: 20,
      });
      if (!tasks.length) {
        return '你当前没有进行中的定时自动任务。';
      }

      let manageLlmEnabled = false;
      let modelProviderKeyId = null;
      let model = null;
      if (wechatScheduledTaskManageLlmConfigService && llmProviderService) {
        try {
          manageLlmEnabled = await wechatScheduledTaskManageLlmConfigService.isManageLlmEnabled();
          if (manageLlmEnabled) {
            const config = await wechatScheduledTaskManageLlmConfigService.getConfig();
            modelProviderKeyId = config.modelProviderKeyId ?? null;
            model = config.model ?? null;
          }
        } catch (err) {
          logger.warn?.(
            '[wechat-scheduled-task-manage-llm] config load failed:',
            err instanceof Error ? err.message : err,
          );
        }
      }

      if (manageLlmEnabled) {
        const decision = await resolveScheduledTaskCancelWithLlm({
          text: agentText,
          tasks,
          llmProviderService,
          modelProviderKeyId,
          model,
          logger,
        });
        if (decision.action === 'cancel' && decision.taskId) {
          const cancelled = await scheduledTaskService.cancelTask({
            userId: user.userId,
            taskId: decision.taskId,
          });
          return formatScheduledTaskCancelReply(cancelled);
        }
        if (decision.action === 'clarify') {
          return decision.message;
        }
        if (decision.llmUnavailable) {
          if (tasks.length === 1) {
            logger.warn?.(
              '[wechat-scheduled-task] outage fallback cancel for single active task',
              { userId: user.userId, taskId: tasks[0].id },
            );
            const cancelled = await scheduledTaskService.cancelTask({
              userId: user.userId,
              taskId: tasks[0].id,
            });
            return formatScheduledTaskCancelReply(cancelled);
          }
          return '暂时无法连接模型来识别要取消的任务，请稍后再试，或明确说出任务名称。';
        }
      }

      return null;
    }
  } catch (err) {
    logger.warn?.(
      '[wechat-scheduled-task] preflight failed:',
      err instanceof Error ? err.message : err,
    );
    return `定时任务设置失败：${err instanceof Error ? err.message : String(err)}`;
  }

  return null;
}