@otto-assistant/bridge 0.4.92

package/dist/tools.js

@@ -0,0 +1,357 @@
+// 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 } from 'node:child_process';
+import net from 'node:net';
+import {} 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, }) {
+    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 = providersResponse.data?.providers || [];
+    // Helper: get last assistant model for a session (non-summary)
+    const getSessionModel = async (sessionId) => {
+        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;
+                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 = providersResponse.data?.providers || [];
+                    const models = [];
+                    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/dist/undo-redo.e2e.test.js

@@ -0,0 +1,161 @@
+// 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);
+});

package/dist/unnest-code-blocks.js

@@ -0,0 +1,146 @@
+// Unnest code blocks from list items for Discord.
+// Discord doesn't render code blocks inside lists, so this hoists them
+// to root level while preserving list structure.
+import { Lexer } from 'marked';
+export function unnestCodeBlocksFromLists(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    const result = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const next = tokens[i + 1];
+        const chunk = (() => {
+            if (token.type === 'list') {
+                const segments = processListToken(token);
+                return renderSegments(segments);
+            }
+            return token.raw;
+        })();
+        if (!chunk) {
+            continue;
+        }
+        const nextRaw = next?.raw ?? '';
+        const needsNewline = nextRaw &&
+            !chunk.endsWith('\n') &&
+            typeof nextRaw === 'string' &&
+            !nextRaw.startsWith('\n');
+        result.push(needsNewline ? chunk + '\n' : chunk);
+    }
+    return result.join('');
+}
+function processListToken(list) {
+    const segments = [];
+    const start = typeof list.start === 'number' ? list.start : parseInt(list.start, 10) || 1;
+    const prefix = list.ordered ? (i) => `${start + i}. ` : () => '- ';
+    for (let i = 0; i < list.items.length; i++) {
+        const item = list.items[i];
+        const itemSegments = processListItem(item, prefix(i));
+        segments.push(...itemSegments);
+    }
+    return segments;
+}
+function processListItem(item, prefix) {
+    const segments = [];
+    let currentText = [];
+    // Track if we've seen a code block - text after code uses continuation prefix
+    let seenCodeBlock = false;
+    const taskMarker = item.task ? (item.checked ? '[x] ' : '[ ] ') : '';
+    let wroteFirstListItem = false;
+    const flushText = () => {
+        const rawText = currentText.join('');
+        const text = rawText.trimEnd();
+        if (text.trim()) {
+            // After a code block, use '-' as continuation prefix to avoid repeating numbers
+            const effectivePrefix = seenCodeBlock ? '- ' : prefix;
+            const marker = !wroteFirstListItem ? taskMarker : '';
+            const normalizedText = normalizeListItemText({
+                text,
+                isTaskItem: item.task,
+            });
+            segments.push({
+                type: 'list-item',
+                prefix: effectivePrefix,
+                content: marker + normalizedText,
+            });
+            wroteFirstListItem = true;
+        }
+        currentText = [];
+    };
+    for (const token of item.tokens) {
+        if (token.type === 'code') {
+            flushText();
+            const codeToken = token;
+            const lang = codeToken.lang || '';
+            segments.push({
+                type: 'code',
+                content: '```' + lang + '\n' + codeToken.text + '\n```\n',
+            });
+            seenCodeBlock = true;
+            continue;
+        }
+        if (token.type === 'list') {
+            flushText();
+            // Recursively process nested list - segments bubble up
+            const nestedSegments = processListToken(token);
+            segments.push(...nestedSegments);
+            continue;
+        }
+        currentText.push(extractText(token));
+    }
+    flushText();
+    // If no segments were created (empty item), return empty
+    if (segments.length === 0) {
+        return [];
+    }
+    // If item had no code blocks (all segments are list-items from this level),
+    // return original raw to preserve formatting
+    const hasCode = segments.some((s) => s.type === 'code');
+    if (!hasCode) {
+        return [{ type: 'list-item', prefix: '', content: item.raw }];
+    }
+    return segments;
+}
+function extractText(token) {
+    // Prefer raw to preserve newlines and markdown markers.
+    if ('raw' in token && typeof token.raw === 'string') {
+        return token.raw;
+    }
+    if (token.type === 'text') {
+        return token.text;
+    }
+    return '';
+}
+function normalizeListItemText({ text, isTaskItem, }) {
+    const withoutIndent = text.replace(/^\s+/, '');
+    if (!isTaskItem) {
+        return withoutIndent;
+    }
+    return withoutIndent.replace(/^\[(?: |x|X)\]\s+/, '');
+}
+function renderSegments(segments) {
+    const result = [];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const prev = segments[i - 1];
+        if (segment.type === 'code') {
+            // Add newline before code if previous was a list item
+            if (prev && prev.type === 'list-item') {
+                result.push('\n');
+            }
+            result.push(segment.content);
+        }
+        else {
+            // list-item
+            if (segment.prefix) {
+                result.push(segment.prefix + segment.content + '\n');
+            }
+            else {
+                // Raw content (no prefix means it's original raw)
+                // Ensure raw ends with newline for proper separation from next segment
+                const raw = segment.content.trimEnd();
+                result.push(raw + '\n');
+            }
+        }
+    }
+    return result.join('').trimEnd();
+}