Chat Mode

// Auth context handles: x402 wallet > JWT token > API key > body.userId > anonymous
const auth = (request as any).auth as AuthContext | undefined;
let userId = auth?.userId || generateUUID();
const source = auth?.method === "x402" ? "x402" : "api";

const planningResult = await planningAgent({
  state,
  conversationState,
  message: createdMessage,
  mode: "initial",
  usageType: "chat",
});

const plan = planningResult.plan;

// Filter to only LITERATURE tasks (no ANALYSIS for regular chat)
const literatureTasks = plan.filter((task) => task.type === "LITERATURE");

for (const task of literatureTasks) {
  const literaturePromises: Promise<void>[] = [];

  // OpenScholar (if OPENSCHOLAR_API_URL configured)
  if (process.env.OPENSCHOLAR_API_URL) {
    literaturePromises.push(
      literatureAgent({
        objective: task.objective,
        type: "OPENSCHOLAR",
      })
    );
  }

  // BioLit (if PRIMARY_LITERATURE_AGENT=BIO)
  if (useBioLiterature) {
    literaturePromises.push(
      literatureAgent({
        objective: task.objective,
        type: "BIOLIT",
      })
    );
  }

  // Knowledge base (if KNOWLEDGE_DOCS_PATH configured)
  if (process.env.KNOWLEDGE_DOCS_PATH) {
    literaturePromises.push(
      literatureAgent({
        objective: task.objective,
        type: "KNOWLEDGE",
      })
    );
  }

  await Promise.all(literaturePromises);
}

/**
 * Check if the question requires a hypothesis using LLM
 */
async function requiresHypothesis(
  question: string,
  literatureResults: string,
  messageId?: string
): Promise<boolean> {
  const prompt = `Analyze this user question and literature results to determine if a research hypothesis is needed.

User Question: ${question}

Literature Results Preview: ${literatureResults.slice(0, 1000)}

A hypothesis IS needed if:
- The question asks about mechanisms, predictions, or causal relationships
- The question requires synthesizing multiple sources into a novel insight
- The question is exploratory and needs a testable proposition

A hypothesis IS NOT needed if:
- The question asks for factual information or definitions
- The question can be answered directly from literature
- The question is a simple lookup or clarification

Respond with ONLY "YES" if a hypothesis is needed, or "NO" if it's not needed.`;

  const response = await llmProvider.createChatCompletion({
    model: process.env.PLANNING_LLM_MODEL || "gemini-2.5-flash",
    messages: [{ role: "user", content: prompt }],
    maxTokens: 10,
  });

  return response.content.trim().toUpperCase() === "YES";
}

const hypothesisResult = await hypothesisAgent({
  objective: planningResult.currentObjective,
  message: createdMessage,
  conversationState,
  completedTasks,
});

conversationState.values.currentHypothesis = hypothesisResult.hypothesis;

const reflectionResult = await reflectionAgent({
  conversationState,
  message: createdMessage,
  completedMaxTasks: completedTasks,
  hypothesis: hypothesisText,
});

// Update conversation state with reflection results
conversationState.values.currentObjective = reflectionResult.currentObjective;
conversationState.values.keyInsights = reflectionResult.keyInsights;
conversationState.values.discoveries = reflectionResult.discoveries;
conversationState.values.methodology = reflectionResult.methodology;

const replyText = await generateChatReply(
  message,
  {
    completedTasks,
    hypothesis: hypothesisText,
    nextPlan: [], // No next plan for regular chat
    keyInsights: conversationState.values.keyInsights || [],
    discoveries: conversationState.values.discoveries || [],
    methodology: conversationState.values.methodology,
    currentObjective: conversationState.values.currentObjective,
    uploadedDatasets: conversationState.values.uploadedDatasets || [],
  },
  {
    maxTokens: 1024,
    messageId: createdMessage.id,
    usageType: "chat",
  }
);

if (isJobQueueEnabled()) {
  // QUEUE MODE: Enqueue job and return immediately
  const job = await chatQueue.add(
    `chat-${createdMessage.id}`,
    {
      userId,
      conversationId,
      messageId: createdMessage.id,
      message,
    },
    {
      jobId: createdMessage.id, // Use message ID as job ID
    }
  );

  return {
    jobId: job.id!,
    messageId: createdMessage.id,
    conversationId,
    userId,
    status: "queued",
    pollUrl: `/api/chat/status/${job.id}`,
  };
}

// Step 1: Process files if any
if (files.length > 0) {
  const { fileUploadAgent } = await import("../agents/fileUpload");

  const fileResult = await fileUploadAgent({
    conversationState,
    files,
    userId: state.values.userId || "unknown",
  });

  // Files are parsed, uploaded to S3, and descriptions generated
}

rateLimitMiddleware("chat")