GitHub API integration and extend DFDA and Tavily services

### Summary:

1. **Add GitHub integration**: Implement `getRepoContents` with `Octokit` for fetching repository contents.
2. **Enhance DFDA services**: Add multiple search functions and improve user authentication and variable fetching logic.
3. **Integrate Tavily client**: Include search functionalities for topics and images using Tavily's API.
4. **Schema and workflow management**: Introduce Zod schemas for various API endpoints and a workflow for inquiry and follow-up handling.

Took 55 seconds

Author: mikepsinn

lib/actions/chat.ts

@@ -0,0 +1,154 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { redirect } from 'next/navigation'
+import { type Chat } from '@/lib/types'
+import { getRedisClient, RedisWrapper } from '@/lib/redis/config'
+
+async function getRedis(): Promise<RedisWrapper> {
+  return await getRedisClient()
+}
+
+export async function getChats(userId?: string | null) {
+  if (!userId) {
+    return []
+  }
+
+  try {
+    const redis = await getRedis()
+    const chats = await redis.zrange(`user:chat:${userId}`, 0, -1, {
+      rev: true
+    })
+
+    if (chats.length === 0) {
+      return []
+    }
+
+    const results = await Promise.all(
+      chats.map(async chatKey => {
+        const chat = await redis.hgetall(chatKey)
+        return chat
+      })
+    )
+
+    return results
+      .filter((result): result is Record<string, any> => {
+        if (result === null || Object.keys(result).length === 0) {
+          return false
+        }
+        return true
+      })
+      .map(chat => {
+        const plainChat = { ...chat }
+        if (typeof plainChat.messages === 'string') {
+          try {
+            plainChat.messages = JSON.parse(plainChat.messages)
+          } catch (error) {
+            plainChat.messages = []
+          }
+        }
+        if (plainChat.createdAt && !(plainChat.createdAt instanceof Date)) {
+          plainChat.createdAt = new Date(plainChat.createdAt)
+        }
+        return plainChat as Chat
+      })
+  } catch (error) {
+    return []
+  }
+}
+
+export async function getChat(id: string, userId: string = 'anonymous') {
+  const redis = await getRedis()
+  const chat = await redis.hgetall<Chat>(`chat:${id}`)
+
+  if (!chat) {
+    return null
+  }
+
+  // Parse the messages if they're stored as a string
+  if (typeof chat.messages === 'string') {
+    try {
+      chat.messages = JSON.parse(chat.messages)
+    } catch (error) {
+      chat.messages = []
+    }
+  }
+
+  // Ensure messages is always an array
+  if (!Array.isArray(chat.messages)) {
+    chat.messages = []
+  }
+
+  return chat
+}
+
+export async function clearChats(
+  userId: string = 'anonymous'
+): Promise<{ error?: string }> {
+  const redis = await getRedis()
+  const chats = await redis.zrange(`user:chat:${userId}`, 0, -1)
+  if (!chats.length) {
+    return { error: 'No chats to clear' }
+  }
+  const pipeline = redis.pipeline()
+
+  for (const chat of chats) {
+    pipeline.del(chat)
+    pipeline.zrem(`user:chat:${userId}`, chat)
+  }
+
+  await pipeline.exec()
+
+  revalidatePath('/')
+  redirect('/')
+}
+
+export async function saveChat(chat: Chat, userId: string = 'anonymous') {
+  try {
+    const redis = await getRedis()
+    const pipeline = redis.pipeline()
+
+    const chatToSave = {
+      ...chat,
+      messages: JSON.stringify(chat.messages)
+    }
+
+    pipeline.hmset(`chat:${chat.id}`, chatToSave)
+    pipeline.zadd(`user:chat:${userId}`, Date.now(), `chat:${chat.id}`)
+
+    const results = await pipeline.exec()
+
+    return results
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function getSharedChat(id: string) {
+  const redis = await getRedis()
+  const chat = await redis.hgetall<Chat>(`chat:${id}`)
+
+  if (!chat || !chat.sharePath) {
+    return null
+  }
+
+  return chat
+}
+
+export async function shareChat(id: string, userId: string = 'anonymous') {
+  const redis = await getRedis()
+  const chat = await redis.hgetall<Chat>(`chat:${id}`)
+
+  if (!chat || chat.userId !== userId) {
+    return null
+  }
+
+  const payload = {
+    ...chat,
+    sharePath: `/search/share/${id}`
+  }
+
+  await redis.hmset(`chat:${id}`, payload)
+
+  return payload
+}

lib/actions/workflow.tsx

@@ -0,0 +1,126 @@
+'use server'
+
+import React from 'react'
+import { Spinner } from '@/components/ui/spinner'
+import { Section } from '@/app/search/components/section'
+import { FollowupPanel } from '@/app/search/components/followup-panel'
+import {
+  querySuggestor,
+  inquire,
+  taskManager,
+  researcherWithOllama,
+  researcher
+} from '@/lib/agents'
+import { createStreamableValue, createStreamableUI } from 'ai/rsc'
+import { CoreMessage, generateId } from 'ai'
+
+export async function workflow(
+  uiState: {
+    uiStream: ReturnType<typeof createStreamableUI>
+    isCollapsed: ReturnType<typeof createStreamableValue>
+    isGenerating: ReturnType<typeof createStreamableValue>
+  },
+  aiState: any,
+  messages: CoreMessage[],
+  skip: boolean
+) {
+  const { uiStream, isCollapsed, isGenerating } = uiState
+  const id = generateId()
+
+  // Display spinner
+  uiStream.append(<Spinner />)
+
+  let action = { object: { next: 'proceed' } }
+  // If the user does not skip the task, run the task manager
+  if (!skip) action = (await taskManager(messages)) ?? action
+
+  if (action.object.next === 'inquire') {
+    // Generate inquiry
+    const inquiry = await inquire(uiStream, messages)
+    uiStream.done()
+    aiState.done({
+      ...aiState.get(),
+      messages: [
+        ...aiState.get().messages,
+        {
+          id: generateId(),
+          role: 'assistant',
+          content: `inquiry: ${inquiry?.question}`,
+          type: 'inquiry'
+        }
+      ]
+    })
+
+    isCollapsed.done(false)
+    isGenerating.done(false)
+    return
+  }
+
+  // Set the collapsed state to true
+  isCollapsed.done(true)
+
+  const useOllama = process.env.OLLAMA_MODEL && process.env.OLLAMA_BASE_URL
+  // Select the appropriate researcher function based on the environment variables
+  const { text, toolResults } = useOllama
+    ? await researcherWithOllama(uiStream, messages)
+    : await researcher(uiStream, messages)
+
+  aiState.update({
+    ...aiState.get(),
+    messages: [
+      ...aiState.get().messages,
+      ...toolResults.map((toolResult: any) => ({
+        id,
+        role: 'tool',
+        content: JSON.stringify(toolResult.result),
+        name: toolResult.toolName,
+        type: 'tool'
+      })),
+      {
+        id,
+        role: 'assistant',
+        content: text,
+        type: 'answer'
+      }
+    ]
+  })
+
+  const messagesWithAnswer: CoreMessage[] = [
+    ...messages,
+    {
+      role: 'assistant',
+      content: text
+    }
+  ]
+
+  // Generate related queries
+  const relatedQueries = await querySuggestor(uiStream, messagesWithAnswer)
+  // Add follow-up panel
+  uiStream.append(
+    <Section title="Follow-up">
+      <FollowupPanel />
+    </Section>
+  )
+
+  uiStream.done()
+  isGenerating.done(false)
+
+  aiState.done({
+    ...aiState.get(),
+    messages: [
+      ...aiState.get().messages,
+      {
+        id,
+        role: 'assistant',
+        content: JSON.stringify(relatedQueries),
+        type: 'related'
+      },
+      {
+        id,
+        role: 'assistant',
+        content: 'followup',
+        type: 'followup'
+      }
+    ]
+  })
+}