kimaki 0.4.82 → 0.4.84

package/src/hrana-server.ts

@@ -2,32 +2,12 @@
 // Backed by the `libsql` npm package (better-sqlite3 API).
 // Binds to the fixed lock port for single-instance enforcement.
 //
-// Serves POST /v2/pipeline (Hrana v2 JSON), GET /v2, and GET /health.
-// The @libsql/client HTTP driver and @prisma/adapter-libsql connect here.
+// Protocol logic is implemented in the `libsqlproxy` package.
+// This file handles: server lifecycle, single-instance enforcement,
+// auth, and kimaki-specific endpoints (/kimaki/wake, /health).
 //
 // Hrana v2 protocol spec ("Hrana over HTTP"):
 //   https://github.com/tursodatabase/libsql/blob/main/docs/HTTP_V2_SPEC.md
-//
-// The protocol exposes stateful streams over HTTP. Each stream corresponds
-// to a SQLite connection. Requests on the same stream are tied together
-// via a "baton" — the server returns a baton in every response, and the
-// client includes it in the next request. Stream-scoped state includes
-// SQL text cached via store_sql (referenced by sql_id in later stmts).
-//
-// Request types implemented:
-//   execute     — run a single SQL statement, return cols/rows/changes
-//   batch       — run multiple steps with conditional execution (ok/not/and/or)
-//   sequence    — split raw SQL by semicolons, execute each (no results)
-//   store_sql   — cache SQL text under a numeric sql_id for the stream
-//   close_sql   — remove a cached sql_id
-//   close       — close the stream (baton becomes null)
-//
-// Value encoding (SQLite → Hrana JSON):
-//   INTEGER → {"type":"integer","value":"42"}  (string, not number)
-//   REAL    → {"type":"float","value":3.14}
-//   TEXT    → {"type":"text","value":"hello"}
-//   BLOB    → {"type":"blob","base64":"..."}
-//   NULL    → {"type":"null"}
 
 import fs from 'node:fs'
 import http from 'node:http'
@@ -35,6 +15,11 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import Database from 'libsql'
 import * as errore from 'errore'
+import {
+  createLibsqlHandler,
+  createLibsqlNodeHandler,
+  libsqlExecutor,
+} from 'libsqlproxy'
 import { createLogger, LogPrefix } from './logger.js'
 import { ServerStartError, FetchError } from './errors.js'
 import { getLockPort } from './config.js'
@@ -156,9 +141,11 @@ export async function startHranaServer({
   database.exec('PRAGMA busy_timeout = 5000')
   db = database
 
-  const hranaHandler = createHranaHandler(database)
+  // Create the Hrana handler using libsqlproxy
+  const hranaFetchHandler = createLibsqlHandler(libsqlExecutor(database))
+  const hranaNodeHandler = createLibsqlNodeHandler(hranaFetchHandler)
 
-  // Combined handler: all control/data routes require the same service auth token.
+  // Combined handler: kimaki-specific endpoints + hrana protocol
   const handler: http.RequestListener = async (req, res) => {
     const pathname = new URL(req.url || '/', 'http://localhost').pathname
     if (pathname === '/kimaki/wake') {
@@ -182,18 +169,20 @@ export async function startHranaServer({
       res.end(JSON.stringify({ ready: true }))
       return
     }
-    // Hrana routes: /health, /v2, /v2/pipeline
+    // Health check — no auth required
     if (pathname === '/health') {
-      hranaHandler(req, res)
+      res.writeHead(200, { 'content-type': 'application/json' })
+      res.end(JSON.stringify({ status: 'ok', pid: process.pid }))
       return
     }
+    // Hrana routes: /v2, /v2/pipeline — require auth
     if (pathname === '/v2' || pathname === '/v2/pipeline') {
       if (!isAuthorizedRequest(req)) {
         res.writeHead(401, { 'content-type': 'application/json' })
         res.end(JSON.stringify({ error: 'unauthorized' }))
         return
       }
-      hranaHandler(req, res)
+      hranaNodeHandler(req, res)
       return
     }
     res.writeHead(404)
@@ -253,368 +242,7 @@ export async function stopHranaServer() {
   hranaLogger.log('Hrana server stopped')
 }
 
-// ── Hrana v2 protocol types ──────────────────────────────────────────────
-
-type HranaValue =
-  | { type: 'null' }
-  | { type: 'integer'; value: string }
-  | { type: 'float'; value: number }
-  | { type: 'text'; value: string }
-  | { type: 'blob'; base64: string }
-
-interface HranaStmt {
-  sql?: string
-  sql_id?: number
-  args?: HranaValue[]
-  named_args?: Array<{ name: string; value: HranaValue }>
-  want_rows?: boolean
-}
-
-interface HranaCondition {
-  type: 'ok' | 'not' | 'and' | 'or'
-  step?: number
-  cond?: HranaCondition
-  conds?: HranaCondition[]
-}
-
-interface HranaBatchStep {
-  stmt: HranaStmt
-  condition?: HranaCondition | null
-}
-
-interface HranaRequest {
-  type: string
-  stmt?: HranaStmt
-  batch?: { steps: HranaBatchStep[] }
-  sql?: string
-  sql_id?: number
-}
-
-interface HranaPipelineRequest {
-  baton: string | null
-  requests: HranaRequest[]
-}
-
-interface HranaColInfo {
-  name: string
-  decltype: string | null
-}
-
-interface HranaExecuteResult {
-  cols: HranaColInfo[]
-  rows: HranaValue[][]
-  affected_row_count: number
-  last_insert_rowid: string | null
-}
-
-// ── Value encoding/decoding ──────────────────────────────────────────────
-
-function encodeValue(val: unknown): HranaValue {
-  if (val === null || val === undefined) return { type: 'null' }
-  if (typeof val === 'bigint') return { type: 'integer', value: val.toString() }
-  if (typeof val === 'number') {
-    if (Number.isInteger(val)) return { type: 'integer', value: val.toString() }
-    return { type: 'float', value: val }
-  }
-  if (typeof val === 'string') return { type: 'text', value: val }
-  if (Buffer.isBuffer(val))
-    return { type: 'blob', base64: val.toString('base64') }
-  if (val instanceof Uint8Array)
-    return { type: 'blob', base64: Buffer.from(val).toString('base64') }
-  return { type: 'text', value: String(val) }
-}
-
-function decodeValue(val: HranaValue): unknown {
-  if (val.type === 'null') return null
-  if (val.type === 'integer') {
-    const n = Number(val.value)
-    return Number.isSafeInteger(n) ? n : BigInt(val.value)
-  }
-  if (val.type === 'float') return val.value
-  if (val.type === 'text') return val.value
-  if (val.type === 'blob') return Buffer.from(val.base64, 'base64')
-  return null
-}
-
-// ── Statement execution ──────────────────────────────────────────────────
-
-// SqliteError from libsql has a `code` property but catch gives Error.
-function getSqliteErrorCode(err: Error): string {
-  return (err as unknown as { code?: string }).code ?? 'SQLITE_ERROR'
-}
-
-function resolveStmtSql(
-  stmt: HranaStmt,
-  sqlStore: Map<number, string>,
-): string {
-  if (stmt.sql != null) return stmt.sql
-  if (stmt.sql_id != null) return sqlStore.get(stmt.sql_id) ?? ''
-  return ''
-}
-
-function bindParams(stmt: HranaStmt): unknown[] {
-  if (stmt.named_args && stmt.named_args.length > 0) {
-    const named: Record<string, unknown> = {}
-    for (const na of stmt.named_args) {
-      named[na.name] = decodeValue(na.value)
-    }
-    return [named]
-  }
-  return (stmt.args ?? []).map(decodeValue)
-}
-
-function executeStmt(
-  database: Database.Database,
-  stmt: HranaStmt,
-  sqlStore: Map<number, string>,
-): HranaExecuteResult {
-  const sql = resolveStmtSql(stmt, sqlStore)
-  const prepared = database.prepare(sql)
-  const params = bindParams(stmt)
-
-  if (prepared.reader) {
-    const cols = prepared.columns()
-    const rows = prepared.all(...params) as Record<string, unknown>[]
-    return {
-      cols: cols.map((c) => ({ name: c.name, decltype: c.type })),
-      rows: rows.map((row) => cols.map((c) => encodeValue(row[c.name]))),
-      affected_row_count: 0,
-      last_insert_rowid: null,
-    }
-  }
-
-  const result = prepared.run(...params)
-  return {
-    cols: [],
-    rows: [],
-    affected_row_count: result.changes,
-    last_insert_rowid:
-      result.lastInsertRowid != null ? result.lastInsertRowid.toString() : null,
-  }
-}
-
-// ── Batch condition evaluation ───────────────────────────────────────────
-
-function evaluateCondition(
-  cond: HranaCondition | null | undefined,
-  stepResults: Array<HranaExecuteResult | null>,
-  stepErrors: Array<{ message: string; code: string } | null>,
-): boolean {
-  if (!cond) return true
-  if (cond.type === 'ok')
-    return stepErrors[cond.step!] === null && stepResults[cond.step!] !== null
-  if (cond.type === 'not')
-    return !evaluateCondition(cond.cond, stepResults, stepErrors)
-  if (cond.type === 'and')
-    return (cond.conds ?? []).every((c) =>
-      evaluateCondition(c, stepResults, stepErrors),
-    )
-  if (cond.type === 'or')
-    return (cond.conds ?? []).some((c) =>
-      evaluateCondition(c, stepResults, stepErrors),
-    )
-  return true
-}
-
-// ── Request handlers ─────────────────────────────────────────────────────
-
-function handleExecute(
-  database: Database.Database,
-  req: HranaRequest,
-  sqlStore: Map<number, string>,
-) {
-  if (!req.stmt)
-    return {
-      type: 'error' as const,
-      error: { message: 'Missing stmt', code: 'HRANA_PROTO_ERROR' },
-    }
-  const result = errore.try({
-    try: () => executeStmt(database, req.stmt!, sqlStore),
-    catch: (e) => e as Error,
-  })
-  if (result instanceof Error) {
-    return {
-      type: 'error' as const,
-      error: { message: result.message, code: getSqliteErrorCode(result) },
-    }
-  }
-  return { type: 'ok' as const, response: { type: 'execute', result } }
-}
-
-function handleBatch(
-  database: Database.Database,
-  req: HranaRequest,
-  sqlStore: Map<number, string>,
-) {
-  const steps = req.batch?.steps ?? []
-  const stepResults: Array<HranaExecuteResult | null> = []
-  const stepErrors: Array<{ message: string; code: string } | null> = []
-
-  for (const step of steps) {
-    if (!evaluateCondition(step.condition, stepResults, stepErrors)) {
-      stepResults.push(null)
-      stepErrors.push(null)
-      continue
-    }
-    const result = errore.try({
-      try: () => executeStmt(database, step.stmt, sqlStore),
-      catch: (e) => e as Error,
-    })
-    if (result instanceof Error) {
-      stepResults.push(null)
-      stepErrors.push({
-        message: result.message,
-        code: getSqliteErrorCode(result),
-      })
-    } else {
-      stepResults.push(result)
-      stepErrors.push(null)
-    }
-  }
-
-  return {
-    type: 'ok' as const,
-    response: {
-      type: 'batch',
-      result: { step_results: stepResults, step_errors: stepErrors },
-    },
-  }
-}
-
-function handleSequence(
-  database: Database.Database,
-  req: HranaRequest,
-  sqlStore: Map<number, string>,
-) {
-  const sql = req.sql ?? (req.sql_id != null ? sqlStore.get(req.sql_id) : null)
-  if (!sql) return { type: 'ok' as const, response: { type: 'sequence' } }
-  const result = errore.try({
-    try: () => {
-      database.exec(sql)
-    },
-    catch: (e) => e as Error,
-  })
-  if (result instanceof Error) {
-    return {
-      type: 'error' as const,
-      error: { message: result.message, code: getSqliteErrorCode(result) },
-    }
-  }
-  return { type: 'ok' as const, response: { type: 'sequence' } }
-}
-
-function processRequest(
-  database: Database.Database,
-  req: HranaRequest,
-  sqlStore: Map<number, string>,
-) {
-  if (req.type === 'execute') return handleExecute(database, req, sqlStore)
-  if (req.type === 'batch') return handleBatch(database, req, sqlStore)
-  if (req.type === 'sequence') return handleSequence(database, req, sqlStore)
-  if (req.type === 'close')
-    return { type: 'ok' as const, response: { type: 'close' } }
-  if (req.type === 'store_sql') {
-    if (req.sql_id != null && req.sql != null) sqlStore.set(req.sql_id, req.sql)
-    return { type: 'ok' as const, response: { type: 'store_sql' } }
-  }
-  if (req.type === 'close_sql') {
-    if (req.sql_id != null) sqlStore.delete(req.sql_id)
-    return { type: 'ok' as const, response: { type: 'close_sql' } }
-  }
-  return {
-    type: 'error' as const,
-    error: {
-      message: `Unknown request type: ${req.type}`,
-      code: 'HRANA_PROTO_ERROR',
-    },
-  }
-}
-
-// ── HTTP handler ─────────────────────────────────────────────────────────
-
-// @libsql/client HTTP driver uses batons to keep streams alive across
-// pipeline requests (needed for interactive transactions). Each stream has
-// its own SQL store for store_sql/close_sql scoping.
-
-let batonCounter = 0
-const streamStores = new Map<string, Map<number, string>>()
-
-export function createHranaHandler(
-  database: Database.Database,
-): http.RequestListener {
-  return (req, res) => {
-    const requestUrl = new URL(req.url || '/', 'http://127.0.0.1')
-
-    if (req.method === 'GET' && requestUrl.pathname === '/health') {
-      res.writeHead(200, { 'content-type': 'application/json' })
-      res.end(JSON.stringify({ status: 'ok', pid: process.pid }))
-      return
-    }
-    if (req.method === 'GET' && requestUrl.pathname === '/v2') {
-      res.writeHead(200, { 'content-type': 'application/json' })
-      res.end('{"version":"hrana-v2"}')
-      return
-    }
-    if (req.method === 'POST' && requestUrl.pathname === '/v2/pipeline') {
-      const chunks: Buffer[] = []
-      let aborted = false
-      req.on('error', () => {
-        aborted = true
-        res.destroy()
-      })
-      req.on('data', (chunk: Buffer) => {
-        chunks.push(chunk)
-      })
-      req.on('end', () => {
-        if (aborted) return
-        const parseResult = errore.try({
-          try: () =>
-            JSON.parse(
-              Buffer.concat(chunks).toString(),
-            ) as HranaPipelineRequest,
-          catch: (e) => e as Error,
-        })
-        if (parseResult instanceof Error) {
-          res.writeHead(400, { 'content-type': 'application/json' })
-          res.end(
-            JSON.stringify({
-              error: {
-                message: parseResult.message,
-                code: 'HRANA_PROTO_ERROR',
-              },
-            }),
-          )
-          return
-        }
-
-        // Resolve or create per-stream SQL store keyed by baton
-        const incoming = parseResult.baton
-        const sqlStore =
-          (incoming ? streamStores.get(incoming) : undefined) ??
-          new Map<number, string>()
-        if (incoming) streamStores.delete(incoming)
-
-        const results = (parseResult.requests ?? []).map((r) =>
-          processRequest(database, r, sqlStore),
-        )
-        const hasClose = (parseResult.requests ?? []).some(
-          (r) => r.type === 'close',
-        )
-
-        const baton = hasClose ? null : `b${++batonCounter}`
-        if (baton) streamStores.set(baton, sqlStore)
-
-        res.writeHead(200, { 'content-type': 'application/json' })
-        res.end(JSON.stringify({ baton, base_url: null, results }))
-      })
-      return
-    }
-    res.writeHead(404)
-    res.end()
-  }
-}
-
-// ── Single-instance enforcement ──────────────────────────────────────────
+// ── Single-instance enforcement ──────────────────────────────────────
 
 /**
  * Evict a previous kimaki instance on the lock port.

package/src/kimaki-opencode-plugin-loading.e2e.test.ts

@@ -46,6 +46,7 @@ test(
     const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' })
     const pluginPath = new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href
     const stderrLines: string[] = []
+    const isolatedOpencodeRoot = path.join(projectDir, 'opencode-test-home')
 
     const {
       command,
@@ -68,6 +69,12 @@ test(
           formatter: false,
           plugin: [pluginPath],
         }),
+        OPENCODE_TEST_HOME: isolatedOpencodeRoot,
+        OPENCODE_CONFIG_DIR: path.join(isolatedOpencodeRoot, '.opencode-kimaki'),
+        XDG_CONFIG_HOME: path.join(isolatedOpencodeRoot, '.config'),
+        XDG_DATA_HOME: path.join(isolatedOpencodeRoot, '.local', 'share'),
+        XDG_CACHE_HOME: path.join(isolatedOpencodeRoot, '.cache'),
+        XDG_STATE_HOME: path.join(isolatedOpencodeRoot, '.local', 'state'),
       },
     })
 

package/src/kimaki-opencode-plugin.ts

@@ -7,8 +7,10 @@
 // - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
 // - context-awareness-plugin: branch, pwd, memory, time gap, onboarding tutorial
 // - opencode-interrupt-plugin: interrupt queued messages at step boundaries
+// - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
 
 export { ipcToolsPlugin } from './ipc-tools-plugin.js'
 export { contextAwarenessPlugin } from './context-awareness-plugin.js'
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js'
+export { kittyGraphicsPlugin } from 'kitty-graphics-agent'

package/src/markdown.test.ts

@@ -131,7 +131,7 @@ beforeAll(async () => {
     const msgs = await client.session.messages({ sessionID })
     const assistantMsg = msgs.data?.find((m) => m.info.role === 'assistant')
     const hasTextParts = assistantMsg?.parts?.some((p) => {
-      return p.type === 'text' && 'text' in p && p.text && !('synthetic' in p && p.synthetic)
+      return p.type === 'text' && p.text && !p.synthetic
     })
     if (hasTextParts) {
       // Extra wait for step-start and other parts to be flushed

package/src/markdown.ts

@@ -315,8 +315,8 @@ export function getCompactSessionContext({
       for (const msg of recentMessages) {
         if (msg.info.role === 'user') {
           const textParts = (msg.parts || [])
-            .filter((p) => p.type === 'text' && 'text' in p)
-            .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
+            .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)}`)
@@ -326,9 +326,9 @@ export function getCompactSessionContext({
           // Get assistant text parts (non-synthetic, non-empty)
           const textParts = (msg.parts || [])
             .filter(
-              (p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text,
+              (p) => p.type === 'text' && !p.synthetic && p.text,
             )
-            .map((p) => ('text' in p ? p.text : ''))
+            .map((p) => (p.type === 'text' ? p.text : ''))
             .filter(Boolean)
           if (textParts.length > 0) {
             lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`)

package/src/message-formatting.ts

@@ -71,36 +71,85 @@ function normalizeWhitespace(text: string): string {
   return text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ')
 }
 
+// A chunk of formatted content with associated part IDs, ready to be
+// batched into as few Discord messages as possible.
+export type SessionChunk = {
+  partIds: string[]
+  content: string
+}
+
 /**
- * Collects and formats the last N assistant parts from session messages.
- * Used by both /resume and /fork to show recent assistant context.
+ * Collect renderable assistant parts from session messages as SessionChunks.
+ * Each non-empty formatted part becomes one chunk. Caller can batch them
+ * with batchChunksForDiscord() before sending.
+ *
+ * - skipPartIds: parts already synced (external sync). Skipped parts are
+ *   not included in the result.
+ * - limit: max parts to include (from the end). Older parts are counted
+ *   in skippedCount.
  */
-export function collectLastAssistantParts({
+export function collectSessionChunks({
   messages,
-  limit = 30,
+  skipPartIds,
+  limit,
 }: {
   messages: GenericSessionMessage[]
+  skipPartIds?: Set<string>
   limit?: number
-}): { partIds: string[]; content: string; skippedCount: number } {
-  const allAssistantParts: { id: string; content: string }[] = []
+}): { chunks: SessionChunk[]; skippedCount: number } {
+  const allChunks: SessionChunk[] = []
 
   for (const message of messages) {
-    if (message.info.role === 'assistant') {
-      for (const part of message.parts) {
-        const content = formatPart(part)
-        if (content.trim()) {
-          allAssistantParts.push({ id: part.id, content: content.trimEnd() })
-        }
+    if (message.info.role !== 'assistant') {
+      continue
+    }
+    for (const part of message.parts) {
+      if (skipPartIds?.has(part.id)) {
+        continue
+      }
+      const content = formatPart(part)
+      if (!content.trim()) {
+        continue
       }
+      allChunks.push({ partIds: [part.id], content: content.trimEnd() })
     }
   }
 
-  const partsToRender = allAssistantParts.slice(-limit)
-  const partIds = partsToRender.map((p) => p.id)
-  const content = partsToRender.map((p) => p.content).join('\n')
-  const skippedCount = allAssistantParts.length - partsToRender.length
+  if (limit !== undefined && allChunks.length > limit) {
+    return {
+      chunks: allChunks.slice(-limit),
+      skippedCount: allChunks.length - limit,
+    }
+  }
+  return { chunks: allChunks, skippedCount: 0 }
+}
 
-  return { partIds, content, skippedCount }
+// Merge consecutive SessionChunks into as few Discord messages as possible,
+// respecting the 2000 char limit.
+const DISCORD_BATCH_MAX_LENGTH = 2000
+
+export function batchChunksForDiscord(chunks: SessionChunk[]): SessionChunk[] {
+  if (chunks.length === 0) {
+    return []
+  }
+  const batched: SessionChunk[] = []
+  let current: SessionChunk = { partIds: [...chunks[0]!.partIds], content: chunks[0]!.content }
+
+  for (let i = 1; i < chunks.length; i++) {
+    const next = chunks[i]!
+    const merged = current.content + '\n' + next.content
+    if (merged.length <= DISCORD_BATCH_MAX_LENGTH) {
+      current = {
+        partIds: [...current.partIds, ...next.partIds],
+        content: merged,
+      }
+    } else {
+      batched.push(current)
+      current = { partIds: [...next.partIds], content: next.content }
+    }
+  }
+  batched.push(current)
+  return batched
 }
 
 export const TEXT_MIME_TYPES = [

package/src/onboarding-tutorial.ts

@@ -146,7 +146,7 @@ ${backticks}bash
 PORT=$((RANDOM % 6000 + 3000))
 tmux kill-session -t game-dev 2>/dev/null
 tmux new-session -d -s game-dev -c "$PWD"
-tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel -p $PORT -- bun run server.ts" Enter
+tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel --kill -p $PORT -- bun run server.ts" Enter
 ${backticks}
 
 Wait a moment, then get the tunnel URL:

package/src/openai-realtime.ts

@@ -250,15 +250,13 @@ export async function startGenAiSession({
     'conversation.item.created',
     ({ item }: { item: ConversationItem }) => {
       if (
-        'role' in item &&
         item.role === 'assistant' &&
         item.type === 'message'
       ) {
         // Check if this is the first audio content
         const hasAudio =
-          'content' in item &&
           Array.isArray(item.content) &&
-          item.content.some((c) => 'type' in c && c.type === 'audio')
+          item.content.some((c) => c.type === 'audio')
         if (hasAudio && !isAssistantSpeaking && onAssistantStartSpeaking) {
           isAssistantSpeaking = true
           onAssistantStartSpeaking()
@@ -277,7 +275,7 @@ export async function startGenAiSession({
       delta: ConversationEventDelta | null
     }) => {
       // Handle audio chunks
-      if (delta?.audio && 'role' in item && item.role === 'assistant') {
+      if (delta?.audio && item.role === 'assistant') {
         if (!isAssistantSpeaking && onAssistantStartSpeaking) {
           isAssistantSpeaking = true
           onAssistantStartSpeaking()
@@ -301,12 +299,10 @@ export async function startGenAiSession({
 
       // Handle transcriptions
       if (delta?.transcript) {
-        if ('role' in item) {
-          if (item.role === 'user') {
-            openaiLogger.log('User transcription:', delta.transcript)
-          } else if (item.role === 'assistant') {
-            openaiLogger.log('Assistant transcription:', delta.transcript)
-          }
+        if (item.role === 'user') {
+          openaiLogger.log('User transcription:', delta.transcript)
+        } else if (item.role === 'assistant') {
+          openaiLogger.log('Assistant transcription:', delta.transcript)
         }
       }
     },