Function ThreadGPT

src/App.tsx:80–486

(props: ThreadGPT)

}

function ThreadGPT(props: ThreadGPT) {
  const query = useQuery({
    queryKey: ['threadgpt', props.nodeId],
    queryFn: async (): Promise<ThreadNode> => {
      const key = storageKey(props.nodeId)
      const node = await ikv.get(key)
      if (!node) {
        const defaultNode = { depth: 0, children: [] }
        await ikv.set(key, defaultNode)
        return defaultNode
      }
      return node
    },
  })
  const nextMessages = useMemo(() => {
    return [
      ...props.previousMessages,
      ...(query.data?.message ? [query.data?.message] : []),
    ]
  }, [query.data?.message, props.previousMessages])
  const mutation = useMutation({
    mutationFn: async (data: { text: string; role: Role } | null) => {
      const text = data?.text ?? null
      const role = data?.role ?? 'user'

      const parentKey = storageKey(props.nodeId)
      const parent = await ikv.get(parentKey)
      if (!parent) {
        throw new Error('Parent node not found')
      }

      async function addNode(message: ThreadNode['message'], response?: any) {
        const id = String(ObjectID())
        const node: ThreadNode = {
          depth: parent.depth + 1,
          children: [],
          message: message,
          response,
          timestamp: new Date().toJSON(),
        }
        await ikv.set(storageKey(id), node)
        parent.children.unshift(id)
      }

      if (text === null) {
        let secretKey = await ikv.get('openaiSecretKey')
        if (!secretKey) {
          secretKey = prompt('Enter OpenAI secret key')
          if (!secretKey) {
            throw new Error('OpenAI secret key is required')
          }
          await ikv.set('openaiSecretKey', secretKey)
          queryClient.invalidateQueries(['models'])
        }

        const response = await createChatCompletion(nextMessages, secretKey)
        for (const [index, choice] of response.data.choices.entries()) {
          await addNode(choice.message, {