theo-agent-dashboard

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README

chat.ts (2372B)

      1 export interface AttachmentInfo {
      2   id: string;
      3   filename: string;
      4   content_type: string;
      5   size_bytes?: number;
      6   created_at: number;
      7 }
      8 
      9 export interface ToolCall {
     10   id: string;
     11   name: string;
     12   args: string;
     13   result: string | null;
     14   status: "pending" | "running" | "complete" | "error";
     15 }
     16 
     17 export interface Message {
     18   id: string;
     19   role: "user" | "assistant" | "system";
     20   content: string;
     21   toolCalls: ToolCall[];
     22   timestamp: number;
     23   model?: string;
     24   forkId?: string;
     25   originalContent?: string;
     26   attachments?: AttachmentInfo[];
     27 }
     28 
     29 interface ChatState {
     30   messages: Message[];
     31   streaming: boolean;
     32   thinkingSessionId: string | null;
     33   addMessage: (message: Message) => void;
     34   updateMessageContent: (id: string, content: string) => void;
     35   addToolCall: (messageId: string, toolCall: ToolCall) => void;
     36   updateToolCall: (
     37     messageId: string,
     38     toolCallId: string,
     39     update: Partial<ToolCall>,
     40   ) => void;
     41   setStreaming: (streaming: boolean) => void;
     42   setThinkingSessionId: (sessionId: string | null) => void;
     43   clearMessages: () => void;
     44   setMessages: (messages: Message[]) => void;
     45 }
     46 
     47 import { create } from "zustand";
     48 
     49 export const useChatStore = create<ChatState>((set) => ({
     50   messages: [],
     51   streaming: false,
     52   thinkingSessionId: null,
     53 
     54   addMessage: (message) =>
     55     set((state) => ({ messages: [...state.messages, message] })),
     56 
     57   updateMessageContent: (id, content) =>
     58     set((state) => ({
     59       messages: state.messages.map((m) =>
     60         m.id === id ? { ...m, content } : m,
     61       ),
     62     })),
     63 
     64   addToolCall: (messageId, toolCall) =>
     65     set((state) => ({
     66       messages: state.messages.map((m) =>
     67         m.id === messageId
     68           ? { ...m, toolCalls: [...m.toolCalls, toolCall] }
     69           : m,
     70       ),
     71     })),
     72 
     73   updateToolCall: (messageId, toolCallId, update) =>
     74     set((state) => ({
     75       messages: state.messages.map((m) =>
     76         m.id === messageId
     77           ? {
     78               ...m,
     79               toolCalls: m.toolCalls.map((tc) =>
     80                 tc.id === toolCallId ? { ...tc, ...update } : tc,
     81               ),
     82             }
     83           : m,
     84       ),
     85     })),
     86 
     87   setStreaming: (streaming) => set({ streaming }),
     88   setThinkingSessionId: (sessionId) => set({ thinkingSessionId: sessionId }),
     89 
     90   clearMessages: () => set({ messages: [], thinkingSessionId: null }),
     91 
     92   setMessages: (messages) => set({ messages }),
     93 }));