Feature/integrate v2 api (#332)

* Integrate new v2 api

* Handle TalkToUser tool call

* Create a new flag for UseV2 API

* Fix user message state in v2 api

* Fix terminal condition in v2 api

* Fix request completion params

* Fix repeat user message

* Fix non stopping execution

* Track source of pending messages

Author: ppsreejith

web/src/app/api/planner.ts

@@ -4,6 +4,7 @@ import { dispatch, logoutState } from '../../state/dispatch';
 import { toast } from '../toast';
 const url = `${configs.PLANNER_BASE_URL}/getLLMResponse`
 const dr_url = `${configs.BASE_SERVER_URL}/deepresearch/chat_planner`
+const dr_url_v2 = `${configs.BASE_SERVER_URL}/deepresearch/v2/chat_planner`
 const dr_tool_url = `${configs.BASE_SERVER_URL}/deepresearch/chat`
 const prewarm_url = `${configs.BASE_SERVER_URL}/deepresearch/chat_plan_warm`
 

web/src/chat/chat.ts

@@ -1,7 +1,7 @@
 import { dispatch } from '../state/dispatch'
-import { addActionPlanMessage, addUserMessage, startNewThread } from '../state/chat/reducer'
+import { addActionPlanMessage, addActionPlanMessageV2, addUserMessage, startNewThread } from '../state/chat/reducer'
 import { DefaultMessageContent } from '../state/chat/types'
-import { LLMResponse } from '../helpers/LLM/types'
+import { LLMResponse, LLMResponseV2 } from '../helpers/LLM/types'
 import { updateCredits } from '../state/billing/reducer'
 import { getState } from '../state/store'
 import { toast } from '../app/toast'
@@ -35,6 +35,11 @@ export default {
     // update credits. not sure if this is the best place to do this
     dispatch(updateCredits(llmResponse.credits))
   },
+  addActionPlanFromLlmResponseV2(llmResponseV2: LLMResponseV2, debug: any) {
+    dispatch(addActionPlanMessageV2({llmResponseV2, debug}))
+    // update credits
+    dispatch(updateCredits(llmResponseV2.credits))
+  },
   async createNewThreadIfNeeded() {
     const state = getState()
     // if on an old thread, create a new one

web/src/components/devtools/Settings.tsx

@@ -1,7 +1,7 @@
 import { Checkbox, Button, Input, VStack, Text, Link, HStack, Box, Divider, AbsoluteCenter, Stack, Switch, Textarea, Radio, RadioGroup, IconButton, Icon, Tag, TagLabel, Badge } from '@chakra-ui/react';
 import React, { useEffect, useState } from 'react';
 import { dispatch, logoutState, resetState } from '../../state/dispatch';
-import { updateIsLocal, updateIsDevToolsOpen, updateUploadLogs, updateDevToolsTabName, DevToolsTabName, setConfirmChanges, setDemoMode, setDRMode, setAnalystMode, setModelsMode, setViewAllCatalogs, setEnableHighlightHelpers, setUseMemory, setEnableStyleCustomization, setEnableUserDebugTools, setEnableReviews, setUseV2States } from '../../state/settings/reducer';
+import { updateIsLocal, updateIsDevToolsOpen, updateUploadLogs, updateDevToolsTabName, DevToolsTabName, setConfirmChanges, setDemoMode, setDRMode, setAnalystMode, setModelsMode, setViewAllCatalogs, setEnableHighlightHelpers, setUseMemory, setEnableStyleCustomization, setEnableUserDebugTools, setEnableReviews, setUseV2States, setUseV2API } from '../../state/settings/reducer';
 import { useSelector } from 'react-redux';
 import { RootState } from '../../state/store';
 import { configs } from '../../constants';
@@ -85,6 +85,7 @@ const SettingsPage = () => {
   const enableUserDebugTools = useSelector((state: RootState) => state.settings.enableUserDebugTools)
   const enableReviews = useSelector((state: RootState) => state.settings.enableReviews)
   const useV2States = useSelector((state: RootState) => state.settings.useV2States)
+  const useV2API = useSelector((state: RootState) => state.settings.useV2API)
   const metadataProcessingCache = useSelector((state: RootState) => state.settings.metadataProcessingCache)
   const isSubscribedOrEnterpriseCustomer = billing.isSubscribed || billing.isEnterpriseCustomer
 
@@ -187,7 +188,10 @@ const SettingsPage = () => {
   const updateUseV2States = (value: boolean) => {
     dispatch(setUseV2States(value))
   }
-  
+  const updateUseV2API = (value: boolean) => {
+    dispatch(setUseV2API(value))
+  }
+
   // const CURRENT_ACTION_TESTS = ACTION_TESTS[tool];
   return (
     <VStack className='settings-body'
@@ -306,6 +310,10 @@ const SettingsPage = () => {
             <Text color={"minusxBW.800"} fontSize="sm">Use v2 states</Text>
             <Switch color={"minusxBW.800"} colorScheme='minusxGreen' size='md' isChecked={useV2States} onChange={(e) => updateUseV2States(e.target.checked)} />
           </HStack>}
+          {configs.IS_DEV && <HStack justifyContent={"space-between"}>
+            <Text color={"minusxBW.800"} fontSize="sm">Use v2 Chat Planner API</Text>
+            <Switch color={"minusxBW.800"} colorScheme='minusxGreen' size='md' isChecked={useV2API} onChange={(e) => updateUseV2API(e.target.checked)} />
+          </HStack>}
         </VStack>
       </SettingsBlock>
       <SettingsBlock title="Privacy">

web/src/helpers/LLM/remote.ts

@@ -1,12 +1,14 @@
 import { ToolCalls } from '../../state/chat/reducer'
-import { LLMResponse } from './types'
+import { LLMResponse, LLMResponseV2, CompletedToolCalls } from './types'
 import { PlanActionsParams } from '.'
 import { getLLMResponse } from '../../app/api'
 import { getApp } from '../app'
 import { getState } from '../../state/store'
 import { set, unset } from 'lodash'
 import { processAllMetadata } from '../metadataProcessor'
 import { getParsedIframeInfo } from '../origin'
+import axios from 'axios'
+import { configs } from '../../constants'
 
 
 export async function planActionsRemote({
@@ -195,7 +197,7 @@ export const convertToMarkdown = async(appState, imgs): Promise<string[]> => {
   }
 
   const systemMessage = `
-  You are an incredible data scientist, and proficient at using jupyter notebooks. 
+  You are an incredible data scientist, and proficient at using jupyter notebooks.
   The user gives you a jupyter state and you must convert it into a markdown document.
   Just give a report as a markdown document based on the notebook
   Don't print any actual code
@@ -225,3 +227,126 @@ export const convertToMarkdown = async(appState, imgs): Promise<string[]> => {
   return content
 }
 
+// V2 API planner
+export async function planActionsRemoteV2({
+  signal,
+  conversationID,
+  meta,
+  user_message
+}: Pick<PlanActionsParams, 'signal' | 'conversationID' | 'meta'> & { user_message: string }): Promise<LLMResponseV2> {
+  const state = getState()
+  const thread = state.chat.activeThread
+  const activeThread = state.chat.threads[thread]
+  const messageHistory = activeThread.messages
+
+  // Find the last user message to get tasks_id
+  const lastUserMessageIdx = messageHistory.findLastIndex((message) => message.role === 'user')
+  if (lastUserMessageIdx === -1) {
+    throw new Error('No user message found in thread')
+  }
+
+  const lastUserMessage = messageHistory[lastUserMessageIdx]
+  const tasks_id = lastUserMessage.tasks_id || null
+
+  // Extract completed tool calls from the last 'pending' planner response only
+  // Find the last assistant message with actions from pending source
+  const completed_tool_calls: Array<{tool_call_id: string, content: string, role: 'tool'}> = []
+  let lastPlanIdx = -1
+  for (let i = messageHistory.length - 1; i >= lastUserMessageIdx; i--) {
+    const msg = messageHistory[i]
+    if (msg.role === 'assistant' && msg.content.type === 'ACTIONS') {
+      lastPlanIdx = i
+      break
+    }
+  }
+
+  // If we found a plan, only extract if it's from pending source (client executed)
+  if (lastPlanIdx !== -1) {
+    const planMessage = messageHistory[lastPlanIdx]
+    if (planMessage.role === 'assistant' && planMessage.content.type === 'ACTIONS' &&
+        planMessage.content.source === 'pending') {
+      // Get all tool messages that belong to this plan and are finished
+      for (const toolMessageIdx of planMessage.content.actionMessageIDs) {
+        const toolMessage = messageHistory[toolMessageIdx]
+        if (toolMessage?.role === 'tool' && toolMessage.action.finished) {
+          let content = ''
+          if (toolMessage.content.type === 'DEFAULT') {
+            content = toolMessage.content.text
+          } else if (toolMessage.content.type === 'BLANK') {
+            content = toolMessage.content.content || ''
+          }
+
+          completed_tool_calls.push({
+            tool_call_id: toolMessage.action.id,
+            content,
+            role: 'tool'
+          })
+        }
+      }
+    }
+  }
+
+  // Build request payload
+  // Only send user_message on first call (when no completed_tool_calls)
+  const payload: any = {
+    conversationID,
+    tasks_id,
+    user_message: completed_tool_calls.length > 0 ? '' : user_message,
+    completed_tool_calls,
+    meta
+  }
+
+  // Add metadata hashes for analyst mode (when both drMode and analystMode are enabled)
+  if (state.settings.drMode && state.settings.analystMode) {
+    try {
+      const dbId = getApp().useStore().getState().toolContext?.dbId || undefined
+      const parsedInfo = getParsedIframeInfo()
+      const { cardsHash, dbSchemaHash, fieldsHash, selectedDbId } = await processAllMetadata(false, dbId)
+
+      payload.cardsHash = cardsHash
+      payload.dbSchemaHash = dbSchemaHash
+      payload.fieldsHash = fieldsHash
+      payload.selectedDbId = `${selectedDbId}`
+      payload.r = parsedInfo.r
+      console.log('[minusx] Added metadata hashes to v2 request for analyst mode')
+    } catch (error) {
+      console.warn('[minusx] Failed to fetch metadata for analyst mode:', error)
+    }
+  }
+
+  // Add selected asset_slug if available and team memory is enabled
+  const selectedAssetSlug = state.settings.selectedAssetId
+  const useTeamMemory = state.settings.useTeamMemory
+  if (selectedAssetSlug && useTeamMemory) {
+    payload.asset_slug = selectedAssetSlug
+    console.log('[minusx] Added asset_slug to v2 request for enhanced context:', selectedAssetSlug)
+  }
+
+  // Make API call
+  const response = await axios.post(
+    `${configs.BASE_SERVER_URL}/deepresearch/v2/chat_planner`,
+    payload,
+    {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      signal
+    }
+  )
+
+  signal.throwIfAborted()
+
+  const jsonResponse = response.data
+  if (jsonResponse.error) {
+    throw new Error(jsonResponse.error)
+  }
+
+  return {
+    pending_tool_calls: jsonResponse.pending_tool_calls || [],
+    completed_tool_calls: jsonResponse.completed_tool_calls || [],
+    tasks_id: jsonResponse.tasks_id,
+    credits: jsonResponse.credits,
+    error: jsonResponse.error
+  }
+}
+

web/src/helpers/LLM/types.ts

@@ -23,6 +23,18 @@ export type LLMResponse = {
   credits?: number
   tasks?: Tasks
 }
+
+// V2 API types
+export type CompletedToolCall = [ToolCalls[0], { tool_call_id: string, content: string }]
+export type CompletedToolCalls = CompletedToolCall[]
+
+export type LLMResponseV2 = {
+  pending_tool_calls: ToolCalls
+  completed_tool_calls: CompletedToolCalls[]  // List of lists of tuples
+  tasks_id?: string | null
+  credits?: number
+  error?: string
+}
 // Should add more stuff here as and when we try to experiment with them
 export type LLMSettings = {
   model: string,

web/src/planner/planner.ts

@@ -13,10 +13,46 @@ import { getParsedIframeInfo } from '../helpers/origin';
 import { configs } from '../constants';
 export const plannerListener = createListenerMiddleware();
 function shouldContinue(getState: () => RootState) {
-  const thread = getState().chat.activeThread
-  const activeThread = getState().chat.threads[thread]
+  const state = getState()
+  const thread = state.chat.activeThread
+  const activeThread = state.chat.threads[thread]
   const messageHistory = activeThread.messages
   const lastMessage = messageHistory[messageHistory.length - 1]
+
+  // For V2 API: check if should continue
+  const useV2Api = state.settings.useV2API && state.settings.drMode
+  if (useV2Api) {
+    // Check if there are any unfinished tool messages (TODO status)
+    const hasUnfinishedTools = messageHistory.some(
+      (msg) => msg.role === 'tool' && !msg.action.finished
+    )
+
+    // If there are unfinished tools, continue to execute them
+    if (hasUnfinishedTools) {
+      return true
+    }
+
+    // Find the last assistant message to check its source
+    const lastAssistantMsg = messageHistory.findLast(
+      (msg) => msg.role === 'assistant' && msg.content.type === 'ACTIONS'
+    )
+
+    if (lastAssistantMsg && lastAssistantMsg.role === 'assistant' && lastAssistantMsg.content.type === 'ACTIONS') {
+      // If tools came from pending (we executed them), send results back to server
+      if (lastAssistantMsg.content.source === 'pending') {
+        return true
+      }
+      // If tools came from completed (server sent them), stop (no more work)
+      if (lastAssistantMsg.content.source === 'completed') {
+        return false
+      }
+    }
+
+    // Default: stop
+    return false
+  }
+
+  // For V1 API: existing logic
   // check if there are 0 tool calls in the last assistant message. if so, we don't continue
   if (lastMessage.role == 'assistant' && lastMessage.content.toolCalls.length == 0) {
     return false
@@ -25,7 +61,7 @@ function shouldContinue(getState: () => RootState) {
   if (lastMessage.role == 'tool' && (lastMessage.action.function.name == 'markTaskDone' || lastMessage.action.function.name == 'UpdateTaskStatus')) {
     return false;
   } else {
-    // if last tool was not respondToUser, we continue anyway. not sure if we should keep it this way? 
+    // if last tool was not respondToUser, we continue anyway. not sure if we should keep it this way?
     return true
   }
 }