@otto-assistant/bridge 0.4.92

package/src/tools.ts

@@ -0,0 +1,430 @@
+// Voice assistant tool definitions for the GenAI worker.
+// Provides tools for managing OpenCode sessions (create, submit, abort),
+// listing chats, searching files, and reading session messages.
+
+import { tool } from './ai-tool.js'
+import { z } from 'zod'
+import { spawn, type ChildProcess } from 'node:child_process'
+import net from 'node:net'
+import {
+  type OpencodeClient,
+  type AssistantMessage,
+  type Provider,
+} from '@opencode-ai/sdk/v2'
+import { createLogger, LogPrefix } from './logger.js'
+import * as errore from 'errore'
+
+const toolsLogger = createLogger(LogPrefix.TOOLS)
+
+import { ShareMarkdown } from './markdown.js'
+import { formatDistanceToNow } from './utils.js'
+import pc from 'picocolors'
+import {
+  initializeOpencodeForDirectory,
+  getOpencodeSystemMessage,
+} from './discord-bot.js'
+
+export async function getTools({
+  onMessageCompleted,
+  directory,
+}: {
+  directory: string
+  onMessageCompleted?: (params: {
+    sessionId: string
+    messageId: string
+    data?: { info: AssistantMessage }
+    error?: unknown
+    markdown?: string
+  }) => void
+}) {
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) {
+    throw new Error(getClient.message)
+  }
+  const client = getClient()
+
+  const markdownRenderer = new ShareMarkdown(client)
+
+  const providersResponse = await client.config.providers()
+  const providers: Provider[] = providersResponse.data?.providers || []
+
+  // Helper: get last assistant model for a session (non-summary)
+  const getSessionModel = async (
+    sessionId: string,
+  ): Promise<{ providerID: string; modelID: string } | undefined> => {
+    const res = await getClient().session.messages({ sessionID: sessionId })
+    const data = res.data
+    if (!data || data.length === 0) return undefined
+    for (let i = data.length - 1; i >= 0; i--) {
+      const info = data?.[i]?.info
+      if (info?.role === 'assistant') {
+        const ai = info as AssistantMessage
+        if (!ai.summary && ai.providerID && ai.modelID) {
+          return { providerID: ai.providerID, modelID: ai.modelID }
+        }
+      }
+    }
+    return undefined
+  }
+
+  const tools = {
+    submitMessage: tool({
+      description:
+        'Submit a message to an existing chat session. Does not wait for the message to complete',
+      inputSchema: z.object({
+        sessionId: z.string().describe('The session ID to send message to'),
+        message: z.string().describe('The message text to send'),
+      }),
+      execute: async ({ sessionId, message }) => {
+        const sessionModel = await getSessionModel(sessionId)
+
+        // do not await
+        getClient()
+          .session.promptAsync({
+            sessionID: sessionId,
+            parts: [{ type: 'text', text: message }],
+            model: sessionModel,
+            system: getOpencodeSystemMessage({ sessionId }),
+          })
+          .then(async (response) => {
+            const markdownResult = await markdownRenderer.generate({
+              sessionID: sessionId,
+              lastAssistantOnly: true,
+            })
+            onMessageCompleted?.({
+              sessionId,
+              messageId: '',
+              markdown: errore.unwrapOr(markdownResult, ''),
+            })
+          })
+          .catch((error) => {
+            onMessageCompleted?.({
+              sessionId,
+              messageId: '',
+              error,
+            })
+          })
+        return {
+          success: true,
+          sessionId,
+          directive: 'Tell user that message has been sent successfully',
+        }
+      },
+    }),
+
+    createNewChat: tool({
+      description:
+        'Start a new chat session with an initial message. Does not wait for the message to complete',
+      inputSchema: z.object({
+        message: z
+          .string()
+          .describe('The initial message to start the chat with'),
+        title: z.string().optional().describe('Optional title for the session'),
+        model: z
+          .object({
+            providerId: z
+              .string()
+              .describe('The provider ID (e.g., "anthropic", "openai")'),
+            modelId: z
+              .string()
+              .describe(
+                'The model ID (e.g., "claude-opus-4-20250514", "gpt-5")',
+              ),
+          })
+          .optional()
+          .describe('Optional model to use for this session'),
+      }),
+      execute: async ({ message, title }) => {
+        if (!message.trim()) {
+          throw new Error(`message must be a non empty string`)
+        }
+
+        try {
+          const session = await getClient().session.create({
+            ...(title ? { title } : {}),
+          })
+
+          if (!session.data) {
+            throw new Error('Failed to create session')
+          }
+
+          // do not await
+          getClient()
+            .session.promptAsync({
+              sessionID: session.data.id,
+              parts: [{ type: 'text', text: message }],
+              system: getOpencodeSystemMessage({ sessionId: session.data.id }),
+            })
+            .then(async (response) => {
+              const markdownResult = await markdownRenderer.generate({
+                sessionID: session.data.id,
+                lastAssistantOnly: true,
+              })
+              onMessageCompleted?.({
+                sessionId: session.data.id,
+                messageId: '',
+                markdown: errore.unwrapOr(markdownResult, ''),
+              })
+            })
+            .catch((error) => {
+              onMessageCompleted?.({
+                sessionId: session.data.id,
+                messageId: '',
+                error,
+              })
+            })
+
+          return {
+            success: true,
+            sessionId: session.data.id,
+            title: session.data.title,
+          }
+        } catch (error) {
+          return {
+            success: false,
+            error:
+              error instanceof Error
+                ? error.message
+                : 'Failed to create chat session',
+          }
+        }
+      },
+    }),
+
+    listChats: tool({
+      description:
+        'Get a list of available chat sessions sorted by most recent',
+      inputSchema: z.object({}),
+      execute: async () => {
+        toolsLogger.log(`Listing opencode sessions`)
+        const sessions = await getClient().session.list()
+
+        if (!sessions.data) {
+          return { success: false, error: 'No sessions found' }
+        }
+
+        const sortedSessions = [...sessions.data]
+          .sort((a, b) => {
+            return b.time.updated - a.time.updated
+          })
+          .slice(0, 20)
+
+        const sessionList = sortedSessions.map(async (session) => {
+          const finishedAt = session.time.updated
+          const status = await (async () => {
+            if (session.revert) return 'error'
+            const messagesResponse = await getClient().session.messages({
+              sessionID: session.id,
+            })
+            const messages = messagesResponse.data || []
+            const lastMessage = messages[messages.length - 1]
+            if (
+              lastMessage?.info.role === 'assistant' &&
+              !lastMessage.info.time.completed
+            ) {
+              return 'in_progress'
+            }
+            return 'finished'
+          })()
+
+          return {
+            id: session.id,
+            folder: session.directory,
+            status,
+            finishedAt: formatDistanceToNow(new Date(finishedAt)),
+            title: session.title,
+            prompt: session.title,
+          }
+        })
+
+        const resolvedList = await Promise.all(sessionList)
+
+        return {
+          success: true,
+          sessions: resolvedList,
+        }
+      },
+    }),
+
+    searchFiles: tool({
+      description: 'Search for files in a folder',
+      inputSchema: z.object({
+        folder: z
+          .string()
+          .optional()
+          .describe(
+            'The folder path to search in, optional. only use if user specifically asks for it',
+          ),
+        query: z.string().describe('The search query for files'),
+      }),
+      execute: async ({ folder, query }) => {
+        const results = await getClient().find.files({
+          query,
+          directory: folder,
+        })
+
+        return {
+          success: true,
+          files: results.data || [],
+        }
+      },
+    }),
+
+    readSessionMessages: tool({
+      description: 'Read messages from a chat session',
+      inputSchema: z.object({
+        sessionId: z.string().describe('The session ID to read messages from'),
+        lastAssistantOnly: z
+          .boolean()
+          .optional()
+          .describe('Only read the last assistant message'),
+      }),
+      execute: async ({ sessionId, lastAssistantOnly = false }) => {
+        if (lastAssistantOnly) {
+          const messages = await getClient().session.messages({
+            sessionID: sessionId,
+          })
+
+          if (!messages.data) {
+            return { success: false, error: 'No messages found' }
+          }
+
+          const assistantMessages = messages.data.filter(
+            (m) => m.info.role === 'assistant',
+          )
+
+          if (assistantMessages.length === 0) {
+            return {
+              success: false,
+              error: 'No assistant messages found',
+            }
+          }
+
+          const lastMessage = assistantMessages[assistantMessages.length - 1]
+          const status =
+            'completed' in lastMessage!.info.time &&
+            lastMessage!.info.time.completed
+              ? 'completed'
+              : 'in_progress'
+
+          const markdownResult = await markdownRenderer.generate({
+            sessionID: sessionId,
+            lastAssistantOnly: true,
+          })
+          if (markdownResult instanceof Error) {
+            throw new Error(markdownResult.message)
+          }
+
+          return {
+            success: true,
+            markdown: markdownResult,
+            status,
+          }
+        } else {
+          const markdownResult = await markdownRenderer.generate({
+            sessionID: sessionId,
+          })
+          if (markdownResult instanceof Error) {
+            throw new Error(markdownResult.message)
+          }
+
+          const messages = await getClient().session.messages({
+            sessionID: sessionId,
+          })
+          const lastMessage = messages.data?.[messages.data.length - 1]
+          const status =
+            lastMessage?.info.role === 'assistant' &&
+            lastMessage?.info.time &&
+            'completed' in lastMessage.info.time &&
+            !lastMessage.info.time.completed
+              ? 'in_progress'
+              : 'completed'
+
+          return {
+            success: true,
+            markdown: markdownResult,
+            status,
+          }
+        }
+      },
+    }),
+
+    abortChat: tool({
+      description: 'Abort/stop an in-progress chat session',
+      inputSchema: z.object({
+        sessionId: z.string().describe('The session ID to abort'),
+      }),
+      execute: async ({ sessionId }) => {
+        try {
+          toolsLogger.log(
+            `[ABORT] reason=voice-tool sessionId=${sessionId} - user requested abort via voice assistant tool`,
+          )
+          const result = await getClient().session.abort({
+            sessionID: sessionId,
+          })
+
+          if (!result.data) {
+            return {
+              success: false,
+              error: 'Failed to abort session',
+            }
+          }
+
+          return {
+            success: true,
+            sessionId,
+            message: 'Session aborted successfully',
+          }
+        } catch (error) {
+          return {
+            success: false,
+            error:
+              error instanceof Error ? error.message : 'Unknown error occurred',
+          }
+        }
+      },
+    }),
+
+    getModels: tool({
+      description: 'Get all available AI models from all providers',
+      inputSchema: z.object({}),
+      execute: async () => {
+        try {
+          const providersResponse = await getClient().config.providers()
+          const providers: Provider[] = providersResponse.data?.providers || []
+
+          const models: Array<{ providerId: string; modelId: string }> = []
+
+          providers.forEach((provider) => {
+            if (provider.models && typeof provider.models === 'object') {
+              Object.entries(provider.models).forEach(([modelId, model]) => {
+                models.push({
+                  providerId: provider.id,
+                  modelId: modelId,
+                })
+              })
+            }
+          })
+
+          return {
+            success: true,
+            models,
+            totalCount: models.length,
+          }
+        } catch (error) {
+          return {
+            success: false,
+            error:
+              error instanceof Error ? error.message : 'Failed to fetch models',
+            models: [],
+          }
+        }
+      },
+    }),
+  }
+
+  return {
+    tools,
+    providers,
+  }
+}

package/src/undici.d.ts

@@ -0,0 +1,12 @@
+// Minimal type declarations for undici (transitive dep from discord.js).
+// We don't list undici in package.json — discord.js bundles it.
+declare module 'undici' {
+  export class Agent {
+    constructor(opts?: {
+      headersTimeout?: number
+      bodyTimeout?: number
+      connections?: number
+    })
+  }
+  export function setGlobalDispatcher(dispatcher: Agent): void
+}

package/src/undo-redo.e2e.test.ts

@@ -0,0 +1,209 @@
+// E2e test for /undo command.
+// Validates that:
+// 1. After /undo, session.revert state is set (files reverted, revert boundary marked)
+// 2. Messages are NOT deleted yet (they stay until next prompt cleans them up)
+// 3. On the next user message, reverted messages are cleaned up by OpenCode's
+//    SessionRevert.cleanup() and the model only sees pre-revert messages
+//
+// This matches the OpenCode TUI behavior (use-session-commands.tsx):
+// - Pass the user message ID (not assistant ID)
+// - Don't delete messages — just mark session as reverted
+// - Cleanup happens automatically on next promptAsync()
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval.
+
+import { describe, test, expect } from 'vitest'
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+} from './test-utils.js'
+import { getThreadSession } from './database.js'
+import { initializeOpencodeForDirectory } from './opencode.js'
+
+const TEXT_CHANNEL_ID = '200000000000001200'
+
+const e2eTest = describe
+
+e2eTest('/undo sets revert state and cleans up on next prompt', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-undo-e2e',
+    dirName: 'qa-undo-e2e',
+    username: 'undo-tester',
+  })
+
+  test(
+    'undo sets revert state, next message cleans up reverted messages',
+    async () => {
+      const markerPath = path.join(
+        ctx.directories.projectDirectory,
+        'tmp',
+        'undo-marker.txt',
+      )
+
+      // 1. Send a message and wait for complete session (footer)
+      await ctx.discord
+        .channel(TEXT_CHANNEL_ID)
+        .user(TEST_USER_ID)
+        .sendMessage({
+          content: 'UNDO_FILE_MARKER',
+        })
+
+      const thread = await ctx.discord
+        .channel(TEXT_CHANNEL_ID)
+        .waitForThread({
+          timeout: 8_000,
+          predicate: (t) => {
+            return t.name === 'UNDO_FILE_MARKER'
+          },
+        })
+
+      const th = ctx.discord.thread(thread.id)
+      await th.waitForBotReply({ timeout: 8_000 })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+      })
+
+      // 2. Get session ID and verify it has messages
+      const sessionId = await getThreadSession(thread.id)
+      expect(sessionId).toBeTruthy()
+
+      const getClient = await initializeOpencodeForDirectory(
+        ctx.directories.projectDirectory,
+      )
+      if (getClient instanceof Error) {
+        throw getClient
+      }
+
+      const beforeMessages = await getClient().session.messages({
+        sessionID: sessionId!,
+        directory: ctx.directories.projectDirectory,
+      })
+      const beforeCount = (beforeMessages.data || []).length
+      expect(beforeCount).toBeGreaterThan(0)
+
+      const beforeUserMessages = (beforeMessages.data || []).filter((m) => {
+        return m.info.role === 'user'
+      })
+      const beforeAssistantMessages = (beforeMessages.data || []).filter(
+        (m) => {
+          return m.info.role === 'assistant'
+        },
+      )
+      expect(beforeUserMessages.length).toBeGreaterThan(0)
+      expect(beforeAssistantMessages.length).toBeGreaterThan(0)
+      expect(fs.existsSync(markerPath)).toBe(true)
+
+      // Verify no revert state yet
+      const beforeSession = await getClient().session.get({
+        sessionID: sessionId!,
+      })
+      expect(beforeSession.data?.revert).toBeFalsy()
+
+      // 3. Run /undo command
+      const { id: undoInteractionId } = await th
+        .user(TEST_USER_ID)
+        .runSlashCommand({ name: 'undo' })
+
+      const undoAck = await th.waitForInteractionAck({
+        interactionId: undoInteractionId,
+        timeout: 4_000,
+      })
+      expect(undoAck).toBeDefined()
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: 'Undone - reverted last assistant message',
+        timeout: 8_000,
+      })
+      // 4. Verify session now has revert state set
+      const afterSession = await getClient().session.get({
+        sessionID: sessionId!,
+      })
+      expect(afterSession.data?.revert).toBeTruthy()
+      expect(afterSession.data?.revert?.messageID).toBeTruthy()
+
+      // Messages should still exist (not deleted — cleanup happens on next prompt)
+      const afterMessages = await getClient().session.messages({
+        sessionID: sessionId!,
+        directory: ctx.directories.projectDirectory,
+      })
+      expect((afterMessages.data || []).length).toBe(beforeCount)
+
+      // 5. Send a new message — this triggers SessionRevert.cleanup()
+      // which removes reverted messages before processing the new prompt
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: after-undo-message',
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 8_000,
+        afterMessageIncludes: 'after-undo-message',
+      })
+
+      // 6. Verify reverted messages were cleaned up
+      const finalMessages = await getClient().session.messages({
+        sessionID: sessionId!,
+        directory: ctx.directories.projectDirectory,
+      })
+      const finalAssistantMessages = (finalMessages.data || []).filter(
+        (m) => {
+          return m.info.role === 'assistant'
+        },
+      )
+
+      // The original assistant message should have been cleaned up,
+      // only the new one (from after-undo-message) should remain
+      const originalAssistantStillExists = finalAssistantMessages.some(
+        (m) => {
+          return m.parts.some((p) => {
+            return p.type === 'text' && 'text' in p && p.text === 'ok'
+          })
+        },
+      )
+      // The first "ok" response was reverted and should be cleaned up.
+      // The new response for "after-undo-message" should produce a fresh "ok".
+      // We verify the total count dropped: the original user+assistant pair
+      // was removed, and replaced by just the new user+assistant pair.
+      expect(finalAssistantMessages.length).toBeLessThanOrEqual(
+        beforeAssistantMessages.length,
+      )
+
+      // Revert state should be cleared after cleanup
+      const finalSession = await getClient().session.get({
+        sessionID: sessionId!,
+      })
+      expect(finalSession.data?.revert).toBeFalsy()
+
+      // 7. Snapshot the Discord thread
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (undo-tester)
+        UNDO_FILE_MARKER
+        --- from: assistant (TestBot)
+        ⬥ creating undo file
+        ⬥ undo file created
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        Undone - reverted last assistant message
+        --- from: user (undo-tester)
+        Reply with exactly: after-undo-message
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+    },
+    20_000,
+  )
+})