@otto-assistant/bridge 0.4.92

package/src/markdown.ts

@@ -0,0 +1,410 @@
+// Session-to-markdown renderer for sharing.
+// Generates shareable markdown from OpenCode sessions, formatting
+// user messages, assistant responses, tool calls, and reasoning blocks.
+// Uses errore for type-safe error handling.
+
+import type { OpencodeClient } from '@opencode-ai/sdk/v2'
+import * as errore from 'errore'
+import { createTaggedError } from 'errore'
+import YAML from 'yaml'
+import { formatDateTime } from './utils.js'
+import { extractNonXmlContent } from './xml.js'
+import { createLogger, LogPrefix } from './logger.js'
+import { SessionNotFoundError, MessagesNotFoundError } from './errors.js'
+
+// Generic error for unexpected exceptions in async operations
+class UnexpectedError extends createTaggedError({
+  name: 'UnexpectedError',
+}) {}
+
+const markdownLogger = createLogger(LogPrefix.MARKDOWN)
+
+const TOOL_OUTPUT_MAX_CHARS = 30_000
+
+export class ShareMarkdown {
+  constructor(private client: OpencodeClient) {}
+
+  /**
+   * Generate a markdown representation of a session
+   * @param options Configuration options
+   * @returns Error or markdown string
+   */
+  async generate(options: {
+    sessionID: string
+    includeSystemInfo?: boolean
+    lastAssistantOnly?: boolean
+  }): Promise<SessionNotFoundError | MessagesNotFoundError | string> {
+    const { sessionID, includeSystemInfo, lastAssistantOnly } = options
+
+    // Get session info
+    const sessionResponse = await this.client.session.get({
+      sessionID,
+    })
+    if (!sessionResponse.data) {
+      return new SessionNotFoundError({ sessionId: sessionID })
+    }
+    const session = sessionResponse.data
+
+    // Get all messages
+    const messagesResponse = await this.client.session.messages({
+      sessionID,
+    })
+    if (!messagesResponse.data) {
+      return new MessagesNotFoundError({ sessionId: sessionID })
+    }
+    const messages = messagesResponse.data
+
+    // If lastAssistantOnly, filter to only the last assistant message
+    const messagesToRender = lastAssistantOnly
+      ? (() => {
+          const assistantMessages = messages.filter(
+            (m) => m.info.role === 'assistant',
+          )
+          return assistantMessages.length > 0
+            ? [assistantMessages[assistantMessages.length - 1]]
+            : []
+        })()
+      : messages
+
+    // Build markdown
+    const lines: string[] = []
+
+    // Only include header and session info if not lastAssistantOnly
+    if (!lastAssistantOnly) {
+      // Header
+      lines.push(`# ${session.title || 'Untitled Session'}`)
+      lines.push('')
+
+      // Session metadata
+      if (includeSystemInfo === true) {
+        lines.push('## Session Information')
+        lines.push('')
+        lines.push(
+          `- **Created**: ${formatDateTime(new Date(session.time.created))}`,
+        )
+        lines.push(
+          `- **Updated**: ${formatDateTime(new Date(session.time.updated))}`,
+        )
+        if (session.version) {
+          lines.push(`- **OpenCode Version**: v${session.version}`)
+        }
+        lines.push('')
+      }
+
+      // Process messages
+      lines.push('## Conversation')
+      lines.push('')
+    }
+
+    for (const message of messagesToRender) {
+      const messageLines = this.renderMessage(message!.info, message!.parts)
+      lines.push(...messageLines)
+      lines.push('')
+    }
+
+    return lines.join('\n')
+  }
+
+  private renderMessage(message: any, parts: any[]): string[] {
+    const lines: string[] = []
+
+    if (message.role === 'user') {
+      lines.push('### 👤 User')
+      lines.push('')
+
+      for (const part of parts) {
+        if (part.type === 'text' && part.text) {
+          const cleanedText = extractNonXmlContent(part.text)
+          if (cleanedText.trim()) {
+            lines.push(cleanedText)
+            lines.push('')
+          }
+        } else if (part.type === 'file') {
+          lines.push(`📎 **Attachment**: ${part.filename || 'unnamed file'}`)
+          if (part.url) {
+            lines.push(`   - URL: ${part.url}`)
+          }
+          lines.push('')
+        }
+      }
+    } else if (message.role === 'assistant') {
+      lines.push(`### 🤖 Assistant (${message.modelID || 'unknown model'})`)
+      lines.push('')
+
+      // Filter and process parts
+      const filteredParts = parts.filter((part) => {
+        if (part.type === 'step-start' && parts.indexOf(part) > 0) return false
+        if (part.type === 'snapshot') return false
+        if (part.type === 'patch') return false
+        if (part.type === 'step-finish') return false
+        if (part.type === 'text' && part.synthetic === true) return false
+        if (part.type === 'tool' && part.tool === 'todoread') return false
+        if (part.type === 'text' && !part.text) return false
+        if (
+          part.type === 'tool' &&
+          (part.state.status === 'pending' || part.state.status === 'running')
+        )
+          return false
+        return true
+      })
+
+      for (const part of filteredParts) {
+        const partLines = this.renderPart(part, message)
+        lines.push(...partLines)
+      }
+
+      // Add completion time if available
+      if (message.time?.completed) {
+        const duration = message.time.completed - message.time.created
+        lines.push('')
+        lines.push(`*Completed in ${this.formatDuration(duration)}*`)
+      }
+    }
+
+    return lines
+  }
+
+  private renderPart(part: any, message: any): string[] {
+    const lines: string[] = []
+
+    switch (part.type) {
+      case 'text':
+        if (part.text) {
+          lines.push(part.text)
+          lines.push('')
+        }
+        break
+
+      case 'reasoning':
+        if (part.text) {
+          lines.push('<details>')
+          lines.push('<summary>💭 Thinking</summary>')
+          lines.push('')
+          lines.push(part.text)
+          lines.push('')
+          lines.push('</details>')
+          lines.push('')
+        }
+        break
+
+      case 'tool':
+        if (part.state.status === 'completed') {
+          const output: string = part.state.output || ''
+          const isOversized = output.length > TOOL_OUTPUT_MAX_CHARS
+
+          if (isOversized) {
+            lines.push(
+              `> ⚠️ **Large tool output** (${output.length.toLocaleString()} chars, truncated to ${TOOL_OUTPUT_MAX_CHARS.toLocaleString()})`,
+            )
+            lines.push('')
+          }
+
+          lines.push(`#### 🛠️ Tool: ${part.tool}`)
+          lines.push('')
+
+          // Render input parameters in YAML
+          if (part.state.input && Object.keys(part.state.input).length > 0) {
+            lines.push('**Input:**')
+            lines.push('```yaml')
+            lines.push(YAML.stringify(part.state.input, null, { lineWidth: 0 }))
+            lines.push('```')
+            lines.push('')
+          }
+
+          // Render output, truncated if too large
+          if (output) {
+            lines.push('**Output:**')
+            lines.push('```')
+            lines.push(
+              isOversized
+                ? output.slice(0, TOOL_OUTPUT_MAX_CHARS) +
+                    '\n...(truncated)'
+                : output,
+            )
+            lines.push('```')
+            lines.push('')
+          }
+
+          // Add timing info if significant
+          if (part.state.time?.start && part.state.time?.end) {
+            const duration = part.state.time.end - part.state.time.start
+            if (duration > 2000) {
+              lines.push(`*Duration: ${this.formatDuration(duration)}*`)
+              lines.push('')
+            }
+          }
+        } else if (part.state.status === 'error') {
+          lines.push(`#### ❌ Tool Error: ${part.tool}`)
+          lines.push('')
+          lines.push('```')
+          lines.push(part.state.error || 'Unknown error')
+          lines.push('```')
+          lines.push('')
+        }
+        break
+
+      case 'step-start':
+        lines.push(`**Started using ${message.providerID}/${message.modelID}**`)
+        lines.push('')
+        break
+    }
+
+    return lines
+  }
+
+  private formatDuration(ms: number): string {
+    if (ms < 1000) return `${ms}ms`
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`
+    const minutes = Math.floor(ms / 60000)
+    const seconds = Math.floor((ms % 60000) / 1000)
+    return `${minutes}m ${seconds}s`
+  }
+}
+
+/**
+ * Generate compact session context for voice transcription.
+ * Includes system prompt (optional), user messages, assistant text,
+ * and tool calls in compact form (name + params only, no output).
+ */
+export function getCompactSessionContext({
+  client,
+  sessionId,
+  includeSystemPrompt = false,
+  maxMessages = 20,
+}: {
+  client: OpencodeClient
+  sessionId: string
+  includeSystemPrompt?: boolean
+  maxMessages?: number
+}): Promise<UnexpectedError | string> {
+  return errore.tryAsync({
+    try: async () => {
+      const messagesResponse = await client.session.messages({
+        sessionID: sessionId,
+      })
+      const messages = messagesResponse.data || []
+
+      const lines: string[] = []
+
+      // Get system prompt if requested
+      // Note: OpenCode SDK doesn't expose system prompt directly. We try multiple approaches:
+      // 1. session.system field (if available in future SDK versions)
+      // 2. synthetic text part in first assistant message (current approach)
+      if (includeSystemPrompt && messages.length > 0) {
+        const firstAssistant = messages.find((m) => m.info.role === 'assistant')
+        if (firstAssistant) {
+          // look for text part marked as synthetic (system prompt)
+          const systemPart = (firstAssistant.parts || []).find(
+            (p) => p.type === 'text' && (p as any).synthetic === true,
+          )
+          if (systemPart && 'text' in systemPart && systemPart.text) {
+            lines.push('[System Prompt]')
+            const truncated = systemPart.text.slice(0, 3000)
+            lines.push(truncated)
+            if (systemPart.text.length > 3000) {
+              lines.push('...(truncated)')
+            }
+            lines.push('')
+          }
+        }
+      }
+
+      // Process recent messages
+      const recentMessages = messages.slice(-maxMessages)
+
+      for (const msg of recentMessages) {
+        if (msg.info.role === 'user') {
+          const textParts = (msg.parts || [])
+            .filter((p) => p.type === 'text')
+            .map((p) => (p.type === 'text' ? extractNonXmlContent(p.text || '') : ''))
+            .filter(Boolean)
+          if (textParts.length > 0) {
+            lines.push(`[User]: ${textParts.join(' ').slice(0, 1000)}`)
+            lines.push('')
+          }
+        } else if (msg.info.role === 'assistant') {
+          // Get assistant text parts (non-synthetic, non-empty)
+          const textParts = (msg.parts || [])
+            .filter(
+              (p) => p.type === 'text' && !p.synthetic && p.text,
+            )
+            .map((p) => (p.type === 'text' ? p.text : ''))
+            .filter(Boolean)
+          if (textParts.length > 0) {
+            lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`)
+            lines.push('')
+          }
+
+          // Get tool calls in compact form (name + params only)
+          const toolParts = (msg.parts || []).filter(
+            (p) =>
+              p.type === 'tool' &&
+              'state' in p &&
+              p.state?.status === 'completed',
+          )
+          for (const part of toolParts) {
+            if (part.type === 'tool' && 'tool' in part && 'state' in part) {
+              const toolName = part.tool
+              // skip noisy tools
+              if (toolName === 'todoread' || toolName === 'todowrite') {
+                continue
+              }
+              const input = part.state?.input || {}
+              const normalize = (value: string) =>
+                value.replace(/\s+/g, ' ').trim()
+              // compact params: just key=value on one line
+              const params = Object.entries(input)
+                .map(([k, v]) => {
+                  const val =
+                    typeof v === 'string'
+                      ? v.slice(0, 100)
+                      : JSON.stringify(v).slice(0, 100)
+                  return `${k}=${normalize(val)}`
+                })
+                .join(', ')
+              lines.push(`[Tool ${toolName}]: ${params}`)
+            }
+          }
+        }
+      }
+
+      return lines.join('\n').slice(0, 8000)
+    },
+    catch: (e) => {
+      markdownLogger.error('Failed to get compact session context:', e)
+      return new UnexpectedError({
+        message: 'Failed to get compact session context',
+        cause: e,
+      })
+    },
+  })
+}
+
+/**
+ * Get the last session for a directory (excluding the current one).
+ */
+export function getLastSessionId({
+  client,
+  excludeSessionId,
+}: {
+  client: OpencodeClient
+  excludeSessionId?: string
+}): Promise<UnexpectedError | (string | null)> {
+  return errore.tryAsync({
+    try: async () => {
+      const sessionsResponse = await client.session.list()
+      const sessions = sessionsResponse.data || []
+
+      // Sessions are sorted by time, get the most recent one that isn't the current
+      const lastSession = sessions.find((s) => s.id !== excludeSessionId)
+      return lastSession?.id || null
+    },
+    catch: (e) => {
+      markdownLogger.error('Failed to get last session:', e)
+      return new UnexpectedError({
+        message: 'Failed to get last session',
+        cause: e,
+      })
+    },
+  })
+}

package/src/message-finish-field.e2e.test.ts

@@ -0,0 +1,192 @@
+// E2e test verifying that the opencode server populates the `finish` field
+// on assistant messages. This field is critical for kimaki's footer logic:
+// isAssistantMessageNaturalCompletion checks `message.finish !== 'tool-calls'`
+// to suppress footers on intermediate tool-call steps.
+// When `finish` is missing/null, every completed assistant message gets a
+// spurious footer, breaking multi-step tool chains (16 test failures).
+//
+// Direct SDK test — no Discord layer needed since this is a server-level bug.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import url from 'node:url'
+import { test, expect, beforeAll, afterAll } from 'vitest'
+import type { OpencodeClient } from '@opencode-ai/sdk/v2'
+import {
+  buildDeterministicOpencodeConfig,
+  type DeterministicMatcher,
+} from 'opencode-deterministic-provider'
+import { setDataDir } from './config.js'
+import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js'
+import { cleanupTestSessions, initTestGitRepo } from './test-utils.js'
+
+const ROOT = path.resolve(process.cwd(), 'tmp', 'finish-field-e2e')
+
+function createRunDirectories() {
+  fs.mkdirSync(ROOT, { recursive: true })
+  const dataDir = fs.mkdtempSync(path.join(ROOT, 'data-'))
+  const projectDirectory = path.join(ROOT, 'project')
+  fs.mkdirSync(projectDirectory, { recursive: true })
+  initTestGitRepo(projectDirectory)
+  return { dataDir, projectDirectory }
+}
+
+function createMatchers(): DeterministicMatcher[] {
+  // Tool-call step: finish="tool-calls"
+  const toolCallMatcher: DeterministicMatcher = {
+    id: 'finish-tool-call',
+    priority: 20,
+    when: {
+      lastMessageRole: 'user',
+      latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'ft' },
+        { type: 'text-delta', id: 'ft', delta: 'calling tool' },
+        { type: 'text-end', id: 'ft' },
+        {
+          type: 'tool-call',
+          toolCallId: 'finish-bash',
+          toolName: 'bash',
+          input: JSON.stringify({ command: 'echo ok', description: 'test' }),
+        },
+        {
+          type: 'finish',
+          finishReason: 'tool-calls',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        },
+      ],
+    },
+  }
+
+  // Follow-up after tool result: finish="stop"
+  const followupMatcher: DeterministicMatcher = {
+    id: 'finish-followup',
+    priority: 21,
+    when: {
+      lastMessageRole: 'tool',
+      latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'ff' },
+        { type: 'text-delta', id: 'ff', delta: 'tool done' },
+        { type: 'text-end', id: 'ff' },
+        {
+          type: 'finish',
+          finishReason: 'stop',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+        },
+      ],
+    },
+  }
+
+  return [toolCallMatcher, followupMatcher]
+}
+
+let client: OpencodeClient
+let directories: ReturnType<typeof createRunDirectories>
+let testStartTime: number
+
+beforeAll(async () => {
+  testStartTime = Date.now()
+  directories = createRunDirectories()
+  setDataDir(directories.dataDir)
+
+  const providerNpm = url
+    .pathToFileURL(
+      path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'),
+    )
+    .toString()
+
+  const opencodeConfig = buildDeterministicOpencodeConfig({
+    providerName: 'deterministic-provider',
+    providerNpm,
+    model: 'deterministic-v2',
+    smallModel: 'deterministic-v2',
+    settings: { strict: false, matchers: createMatchers() },
+  })
+  fs.writeFileSync(
+    path.join(directories.projectDirectory, 'opencode.json'),
+    JSON.stringify(opencodeConfig, null, 2),
+  )
+
+  const getClient = await initializeOpencodeForDirectory(directories.projectDirectory)
+  if (getClient instanceof Error) {
+    throw getClient
+  }
+  client = getClient()
+}, 60_000)
+
+afterAll(async () => {
+  await cleanupTestSessions({
+    projectDirectory: directories.projectDirectory,
+    testStartTime,
+  })
+  await stopOpencodeServer()
+}, 10_000)
+
+test('tool-call step has finish="tool-calls", follow-up has finish="stop"', async () => {
+  const session = await client.session.create({
+    directory: directories.projectDirectory,
+    title: 'finish-field-test',
+  })
+  const sessionID = session.data!.id
+
+  await client.session.promptAsync({
+    sessionID,
+    directory: directories.projectDirectory,
+    parts: [{ type: 'text', text: 'FINISH_FIELD_TOOLCALL' }],
+  })
+
+  // Poll until we have 2 completed assistant messages (tool-call + follow-up)
+  const maxWait = 8_000
+  const pollStart = Date.now()
+  let completedAssistants: Array<{ finish: string | null; partTypes: string[] }> = []
+
+  while (Date.now() - pollStart < maxWait) {
+    const msgs = await client.session.messages({ sessionID })
+    completedAssistants = (msgs.data || [])
+      .filter((m) => {
+        return m.info.role === 'assistant' && m.info.time.completed
+      })
+      .map((m) => {
+        return {
+          finish: (m.info as Record<string, unknown>).finish as string | null ?? null,
+          partTypes: m.parts.map((p) => { return p.type }),
+        }
+      })
+    if (completedAssistants.length >= 2) {
+      break
+    }
+    await new Promise((resolve) => { setTimeout(resolve, 100) })
+  }
+
+  // Snapshot completed assistant messages — finish should NOT be null
+  expect(completedAssistants).toMatchInlineSnapshot(`
+    [
+      {
+        "finish": "tool-calls",
+        "partTypes": [
+          "step-start",
+          "text",
+          "step-finish",
+        ],
+      },
+      {
+        "finish": "stop",
+        "partTypes": [
+          "step-start",
+          "text",
+          "step-finish",
+        ],
+      },
+    ]
+  `)
+
+  const finishes = completedAssistants.map((m) => { return m.finish })
+  expect(finishes).toEqual(['tool-calls', 'stop'])
+}, 15_000)

package/src/message-formatting.test.ts

@@ -0,0 +1,81 @@
+import { describe, test, expect } from 'vitest'
+import { formatTodoList } from './message-formatting.js'
+import type { Part } from '@opencode-ai/sdk/v2'
+
+describe('formatTodoList', () => {
+  test('formats active todo with monospace numbers', () => {
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: {
+          todos: [
+            { content: 'First task', status: 'completed' },
+            { content: 'Second task', status: 'in_progress' },
+            { content: 'Third task', status: 'pending' },
+          ],
+        },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⒉ **second task**"`)
+  })
+
+  test('formats double digit todo numbers', () => {
+    const todos = Array.from({ length: 12 }, (_, i) => ({
+      content: `Task ${i + 1}`,
+      status: i === 11 ? 'in_progress' : 'completed',
+    }))
+
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: { todos },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⒓ **task 12**"`)
+  })
+
+  test('lowercases first letter of content', () => {
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: {
+          todos: [{ content: 'Fix the bug', status: 'in_progress' }],
+        },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⒈ **fix the bug**"`)
+  })
+})