wip(chat db): create thread, subscribe and send messages.

Author: MarcMcIntosh

refact-agent/gui/src/components/ChatHistory/ChatHistory.tsx

@@ -38,6 +38,7 @@ function useGetHistory() {
     const thunk = dispatch(subscribeToThreadsThunk());
     return () => {
       try {
+        thunk.catch(() => ({}));
         thunk.abort("unmounted");
       } catch {
         // noop

refact-agent/gui/src/features/ChatDB/chatDbMessagesSlice.ts

@@ -2,13 +2,11 @@ import { createSlice, PayloadAction } from "@reduxjs/toolkit";
 import {
   CMessageFromChatDB,
   CThread,
-  CThreadDefault,
   CMessage,
   ChatMessage,
   UserCMessage,
   isUserCMessage,
 } from "../../services/refact";
-import { v4 as uuid } from "uuid";
 import { parseOrElse } from "../../utils";
 import { makeMessageTree } from "./makeMessageTree";
 import { pagesSlice } from "../Pages/pagesSlice";
@@ -31,22 +29,20 @@ export function isUserCMessageNode(
 }
 
 type InitialState = {
-  thread: CThread | CThreadDefault;
+  thread: Pick<CThread, "cthread_id" | "cthread_model" | "cthread_toolset">;
   messageList: CMessage[];
   loading: boolean;
   error: null | string;
   endNumber: number;
   endAlt: number;
 };
 
-const createChatThread = (): CThreadDefault => {
-  const thread: CThreadDefault = {
-    cthread_id: uuid(),
-    cthread_title: "",
+const createChatThread = (): InitialState["thread"] => {
+  const thread = {
+    cthread_id: "",
     cthread_toolset: "",
     cthread_model: "",
   };
-
   return thread;
 };
 
@@ -75,7 +71,7 @@ export const chatDbMessageSlice = createSlice({
   name: "chatDbMessages",
   initialState,
   reducers: {
-    setThread: (state, action: PayloadAction<CThread>) => {
+    setThread: (state, action: PayloadAction<InitialState["thread"]>) => {
       state.thread = action.payload;
     },
     updateMessage: (
@@ -114,17 +110,17 @@ export const chatDbMessageSlice = createSlice({
     builder.addMatcher(pagesSlice.actions.push.match, (state, action) => {
       if (action.payload.name !== "chat") return state;
       if (action.payload.threadId !== undefined) return state;
-      // TODO: other data passed from previouly used chat.
       const thread = createChatThread();
       thread.cthread_model = state.thread.cthread_model;
       thread.cthread_toolset = state.thread.cthread_toolset;
-      state = { ...initialState, thread };
+      return { ...initialState, thread };
     });
   },
 
   selectors: {
     selectMessageTree: (state) => makeMessageTree(state.messageList),
     selectThread: (state) => state.thread,
+    selectThreadId: (state) => state.thread.cthread_id,
     selectLeafEndPosition: (state) => ({
       num: state.endNumber,
       alt: state.endAlt,

refact-agent/gui/src/hooks/useThreadMessageSubmit.ts

@@ -1,62 +1,83 @@
 import { useCallback, useMemo } from "react";
+import { v4 as uuidv4 } from "uuid";
 import { useAppSelector } from "./useAppSelector";
-import { chatDbMessagesSliceSelectors } from "../features/ChatDB/chatDbMessagesSlice";
-import { chatDbSelectors } from "../features/ChatDB/chatDbSlice";
 import {
-  sendMessagesThunk,
+  chatDbMessageSliceActions,
+  chatDbMessagesSliceSelectors,
+} from "../features/ChatDB/chatDbMessagesSlice";
+import {
+  updateCMessagesThunk,
   updateThreadThunk,
 } from "../services/refact/chatdb";
 import { useAppDispatch } from "./useAppDispatch";
 import { useSendChatRequest } from "./useSendChatRequest";
-import { getSelectedSystemPrompt } from "../features/Chat/Thread/selectors";
+import {
+  getSelectedSystemPrompt,
+  selectThreadToolUse,
+} from "../features/Chat/Thread/selectors";
 import { CMessage, SystemMessage } from "../services/refact";
+import { useGetCapsQuery } from "./useGetCapsQuery";
+import { useGetPromptsQuery } from "./useGetPromptsQuery";
 
 export function useThreadMessageSubmit() {
   const dispatch = useAppDispatch();
   const { maybeAddImagesToQuestion } = useSendChatRequest();
-  const systemPrompt = useAppSelector(getSelectedSystemPrompt);
+  const selectedSystemPrompt = useAppSelector(getSelectedSystemPrompt);
+  const prompts = useGetPromptsQuery();
+  const toolUse = useAppSelector(selectThreadToolUse);
+  const caps = useGetCapsQuery();
 
   const thread = useAppSelector(chatDbMessagesSliceSelectors.selectThread);
   const leafPosition = useAppSelector(
     chatDbMessagesSliceSelectors.selectLeafEndPosition,
   );
 
-  const maybeSavedThread = useAppSelector((state) =>
-    chatDbSelectors.getThreadById(state, thread.cthread_id),
-  );
+  const systemMessageText = useMemo(() => {
+    const defualtPropmpt = prompts.data?.default?.text ?? "";
+    const selected = Object.values(selectedSystemPrompt);
+    const prompt = selected.length > 0 ? selected[0].text : defualtPropmpt;
+    return prompt;
+  }, [prompts.data, selectedSystemPrompt]);
 
   const isNew = useMemo(() => {
-    return (
-      !!maybeSavedThread && leafPosition.num === 0 && leafPosition.alt === 0
-    );
-  }, [leafPosition.alt, leafPosition.num, maybeSavedThread]);
+    return !thread.cthread_id;
+  }, [thread.cthread_id]);
 
   // TODO: use the hooks from crateApi for submitting threads and messages
   const submit = useCallback(
     async (question: string) => {
-      if (isNew) {
-        const threadThunk = updateThreadThunk(thread);
-        await dispatch(threadThunk);
-      }
+      const threadId = thread.cthread_id || uuidv4();
+      const threadModel =
+        (thread.cthread_model || caps.data?.code_chat_default_model) ?? "";
+      const threadToolUse = (thread.cthread_toolset || toolUse) ?? "";
+      const newThread = {
+        ...thread,
+        cthread_id: threadId,
+        cthread_model: threadModel,
+        cthread_toolset: threadToolUse,
+      };
 
       const messagesToSend: CMessage[] = [];
 
-      if (
-        isNew &&
-        !("default" in systemPrompt) &&
-        Object.values(systemPrompt).length > 0
-      ) {
+      console.log({ thread, isNew });
+
+      if (isNew) {
+        const threadThunk = updateThreadThunk(newThread);
+        await dispatch(threadThunk); // .unwrap(); // TODO: handle errors
+        // this will subscribe to the thread's message list
+        dispatch(chatDbMessageSliceActions.setThread(newThread));
+
         const systemMessage: SystemMessage = {
           role: "system",
-          content: Object.values(systemPrompt)[0].text,
+          content: systemMessageText,
         };
 
         const systemCMessage: CMessage = {
-          cmessage_belongs_to_cthread_id: thread.cthread_id,
+          cmessage_belongs_to_cthread_id: threadId,
           cmessage_alt: 0,
           cmessage_num: -1,
           cmessage_prev_alt: 0,
-          cmessage_usage_model: thread.cthread_model,
+          cmessage_usage_model: threadModel, // could be default
           cmessage_usage_prompt: 0,
           cmessage_usage_completion: 0,
           cmessage_json: systemMessage,
@@ -65,36 +86,36 @@ export function useThreadMessageSubmit() {
         messagesToSend.push(systemCMessage);
       }
 
-      // TODO: add system message
-
       const userMessage = maybeAddImagesToQuestion(question);
       const userCMessage: CMessage = {
-        cmessage_belongs_to_cthread_id: thread.cthread_id,
+        cmessage_belongs_to_cthread_id: threadId,
         cmessage_alt: leafPosition.alt,
-        cmessage_num: leafPosition.num,
-        cmessage_prev_alt: leafPosition.alt, // TODO: add this
-        cmessage_usage_model: thread.cthread_model,
+        cmessage_num: leafPosition.num + 1,
+        cmessage_prev_alt: leafPosition.alt, // TODO: add this to end tracker
+        cmessage_usage_model: threadModel,
         cmessage_usage_prompt: 0,
         cmessage_usage_completion: 0,
         cmessage_json: userMessage,
       };
 
       messagesToSend.push(userCMessage);
 
-      const thunk = await dispatch(
-        sendMessagesThunk({ messages: messagesToSend }),
-      );
+      console.log({ isNew, messagesToSend });
+
+      const thunk = await dispatch(updateCMessagesThunk(messagesToSend));
 
       return thunk;
     },
     [
+      caps.data?.code_chat_default_model,
       dispatch,
       isNew,
       leafPosition.alt,
       leafPosition.num,
       maybeAddImagesToQuestion,
-      systemPrompt,
+      systemMessageText,
       thread,
+      toolUse,
     ],
   );
 

refact-agent/gui/src/hooks/useThreadMessageSubscription.ts

@@ -1,19 +1,19 @@
 import { useEffect } from "react";
-import { useThreadId } from "./useThreadId";
 import { useAppDispatch } from "./useAppDispatch";
 import { subscribeToThreadMessagesThunk } from "../services/refact";
-// import { useAppSelector } from "./useAppSelector";
-// import { chatDbSelectors } from "../features/ChatDB/chatDbSlice";
+import { useAppSelector } from "./useAppSelector";
+import { chatDbMessagesSliceSelectors } from "../features/ChatDB/chatDbMessagesSlice";
 
 export function useThreadMessageSubscription() {
-  // looks like we need to create the thread before subscribing.
-  const threadId = useThreadId();
+  const threadId = useAppSelector(chatDbMessagesSliceSelectors.selectThreadId);
   const dispatch = useAppDispatch();
   useEffect(() => {
+    console.log("Subscribe to thread messages: " + threadId);
     const thunk = dispatch(subscribeToThreadMessagesThunk(threadId));
     return () => {
       try {
-        thunk.abort("useThreadMessageSubscription unmounted");
+        thunk.catch(() => ({}));
+        thunk.abort(`aborted: subscribeToThreadMessagesThunk(${threadId})`);
       } catch (e) {
         // no-op
       }

refact-agent/gui/src/services/refact/chatdb.ts

@@ -4,6 +4,7 @@ import {
   CHAT_DB_THREADS_SUB,
   CHAT_DB_MESSAGES_SUB,
   CHAT_DB_MESSAGES_UPDATE,
+  CHAT_DB_THREADS_UPDATE,
 } from "./consts";
 import { consumeStream } from "../../features/Chat/Thread/utils";
 import {
@@ -15,10 +16,7 @@ import {
   CMessageFromChatDB,
 } from "./types";
 import { chatDbActions } from "../../features/ChatDB/chatDbSlice";
-import {
-  chatDbMessageSlice,
-  chatDbMessageSliceActions,
-} from "../../features/ChatDB/chatDbMessagesSlice";
+import { chatDbMessageSliceActions } from "../../features/ChatDB/chatDbMessagesSlice";
 
 const createAppAsyncThunk = createAsyncThunk.withTypes<{
   state: RootState;
@@ -108,7 +106,7 @@ export function updateThread(
   port = 8001,
   apiKey?: string | null,
 ): Promise<Response> {
-  const url = `http://127.0.0.1:${port}${CHAT_DB_THREADS_SUB}`;
+  const url = `http://127.0.0.1:${port}${CHAT_DB_THREADS_UPDATE}`;
   const headers = new Headers();
   headers.append("Content-Type", "application/json");
   if (apiKey) {
@@ -131,7 +129,11 @@ export const updateThreadThunk = createAppAsyncThunk<
   const state = thunkApi.getState() as unknown as RootState;
   const port = state.config.lspPort;
   const apiKey = state.config.apiKey;
-  return updateThread(thread, port, apiKey);
+  console.log("calling updateThread");
+  return updateThread(thread, port, apiKey).then((res) => {
+    console.log("update tread done");
+    return res.json();
+  });
 });
 
 function subscribeToThreadMessages(
@@ -161,6 +163,7 @@ export const subscribeToThreadMessagesThunk = createAppAsyncThunk<
   unknown,
   string
 >("chatDbApi/subscribeToThreadMessages", (cthreadId, thunkApi) => {
+  if (!cthreadId) return;
   const state = thunkApi.getState() as unknown as RootState;
   const port = state.config.lspPort;
   const apiKey = state.config.apiKey;
@@ -232,27 +235,29 @@ export const updateCMessagesThunk = createAppAsyncThunk<unknown, CMessage[]>(
     const state = thunkApi.getState() as unknown as RootState;
     const port = state.config.lspPort;
     const apiKey = state.config.apiKey;
-    return updateCMessage(cmessages, port, apiKey);
+    return updateCMessage(cmessages, port, apiKey).then((res) => res.json());
   },
 );
 
-export const sendMessagesThunk = createAppAsyncThunk<
-  unknown,
-  {
-    messages: CMessage[];
-  }
->("chatDbApi/sendThreadAndMessagesThunk", async (args, thunkApi) => {
-  if (args.messages.length === 0) return;
-  const id = args.messages.map((m) => m.cmessage_belongs_to_cthread_id)[0];
-  await thunkApi.dispatch(
-    updateThreadThunk({
-      cthread_id: id,
-      cthread_updated_ts: new Date().getTime(),
-    }),
-  );
-
-  await thunkApi.dispatch(updateCMessagesThunk(args.messages));
-});
+// export const sendMessagesThunk = createAppAsyncThunk<
+//   unknown,
+//   {
+//     messages: CMessage[];
+//   }
+// >("chatDbApi/sendThreadAndMessagesThunk", async (args, thunkApi) => {
+//   if (args.messages.length === 0) return;
+//   const id = args.messages.map((m) => m.cmessage_belongs_to_cthread_id)[0];
+//   await thunkApi.dispatch(
+//     updateThreadThunk({
+//       cthread_id: id,
+//       cthread_updated_ts: new Date().getTime(),
+//     }),
+//   );
+
+//   await thunkApi.dispatch(updateCMessagesThunk(args.messages));
+// });
+
+// TODO: create thread an subscribe to messages
 
 // Types for the API
 

refact-agent/gui/src/services/refact/consts.ts

@@ -42,6 +42,6 @@ export const KNOWLEDGE_UPDATE_URL = "/v1/mem-upd";
 export const KNOWLEDGE_CREATE_URL = "/v1/trajectory-save";
 // Chatdblinks
 export const CHAT_DB_THREADS_SUB = "/db_v1/cthreads-sub";
-export const CHAT_DB_THREADS_UPDATE = "/db_v1/cthreads-update";
+export const CHAT_DB_THREADS_UPDATE = "/db_v1/cthread-update";
 export const CHAT_DB_MESSAGES_SUB = "/db_v1/cmessages-sub";
 export const CHAT_DB_MESSAGES_UPDATE = "/db_v1/cmessages-update";

refact-agent/gui/src/services/refact/types.ts

@@ -697,13 +697,7 @@ export function isMCPEnvironmentsDict(json: unknown): json is MCPEnvs {
 
 // ChatDB
 
-export type CThreadDefault = {
-  cthread_id: string;
-  cthread_title: string;
-  cthread_toolset: string;
-  cthread_model: string;
-};
-export type CThread = CThreadDefault & {
+export type CThread = {
   cthread_id: string;
   cthread_belongs_to_chore_event_id: string | null;
   cthread_title: string;
@@ -721,6 +715,13 @@ export type CThread = CThreadDefault & {
   cthread_locked_by: string;
   cthread_locked_ts: number;
 };
+
+// export type CThreadDefault = Partial<CThread> & {
+//   cthread_id: null | string;
+//   cthread_title: string;
+//   cthread_toolset: string;
+//   cthread_model: string;
+// };
 export function isCThread(value: unknown): value is CThread {
   if (!value || typeof value !== "object") {
     return false;