kimaki 0.4.25 → 0.4.26

package/src/session-handler.ts

@@ -2,48 +2,28 @@
 // Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
 // Handles streaming events, permissions, abort signals, and message queuing.
 
-import type { Part, FilePartInput, Permission } from '@opencode-ai/sdk'
+import type { Part, PermissionRequest } from '@opencode-ai/sdk/v2'
+import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message, ThreadChannel } from 'discord.js'
 import prettyMilliseconds from 'pretty-ms'
-import { getDatabase, getSessionModel, getChannelModel } from './database.js'
-import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js'
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent } from './database.js'
+import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from './discord-utils.js'
 import { formatPart } from './message-formatting.js'
 import { getOpencodeSystemMessage } from './system-message.js'
 import { createLogger } from './logger.js'
 import { isAbortError } from './utils.js'
+import { showAskUserQuestionDropdowns } from './commands/ask-question.js'
 
 const sessionLogger = createLogger('SESSION')
 const voiceLogger = createLogger('VOICE')
 const discordLogger = createLogger('DISCORD')
 
-export type ParsedCommand = {
-  isCommand: true
-  command: string
-  arguments: string
-} | {
-  isCommand: false
-}
-
-export function parseSlashCommand(text: string): ParsedCommand {
-  const trimmed = text.trim()
-  if (!trimmed.startsWith('/')) {
-    return { isCommand: false }
-  }
-  const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/)
-  if (!match) {
-    return { isCommand: false }
-  }
-  const command = match[1]!
-  const args = match[2]?.trim() || ''
-  return { isCommand: true, command, arguments: args }
-}
-
 export const abortControllers = new Map<string, AbortController>()
 
 export const pendingPermissions = new Map<
   string,
-  { permission: Permission; messageId: string; directory: string }
+  { permission: PermissionRequest; messageId: string; directory: string }
 >()
 
 export type QueuedMessage = {
@@ -79,22 +59,96 @@ export function clearQueue(threadId: string): void {
   messageQueue.delete(threadId)
 }
 
+/**
+ * Abort a running session and retry with the last user message.
+ * Used when model preference changes mid-request.
+ * Fetches last user message from OpenCode API instead of tracking in memory.
+ * @returns true if aborted and retry scheduled, false if no active request
+ */
+export async function abortAndRetrySession({
+  sessionId,
+  thread,
+  projectDirectory,
+}: {
+  sessionId: string
+  thread: ThreadChannel
+  projectDirectory: string
+}): Promise<boolean> {
+  const controller = abortControllers.get(sessionId)
+
+  if (!controller) {
+    sessionLogger.log(`[ABORT+RETRY] No active request for session ${sessionId}`)
+    return false
+  }
+
+  sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`)
+
+  // Abort with special reason so we don't show "completed" message
+  controller.abort('model-change')
+
+  // Also call the API abort endpoint
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  try {
+    await getClient().session.abort({ path: { id: sessionId } })
+  } catch (e) {
+    sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, e)
+  }
+
+  // Small delay to let the abort propagate
+  await new Promise((resolve) => { setTimeout(resolve, 300) })
+
+  // Fetch last user message from API
+  sessionLogger.log(`[ABORT+RETRY] Fetching last user message for session ${sessionId}`)
+  const messagesResponse = await getClient().session.messages({ path: { id: sessionId } })
+  const messages = messagesResponse.data || []
+  const lastUserMessage = [...messages].reverse().find((m) => m.info.role === 'user')
+
+  if (!lastUserMessage) {
+    sessionLogger.log(`[ABORT+RETRY] No user message found in session ${sessionId}`)
+    return false
+  }
+
+  // Extract text and images from parts
+  const textPart = lastUserMessage.parts.find((p) => p.type === 'text') as { type: 'text'; text: string } | undefined
+  const prompt = textPart?.text || ''
+  const images = lastUserMessage.parts.filter((p) => p.type === 'file') as FilePartInput[]
+
+  sessionLogger.log(`[ABORT+RETRY] Re-triggering session ${sessionId} with new model`)
+
+  // Use setImmediate to avoid blocking
+  setImmediate(() => {
+    handleOpencodeSession({
+      prompt,
+      thread,
+      projectDirectory,
+      images,
+    }).catch(async (e) => {
+      sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, e)
+      const errorMsg = e instanceof Error ? e.message : String(e)
+      await sendThreadMessage(thread, `✗ Failed to retry with new model: ${errorMsg.slice(0, 200)}`)
+    })
+  })
+
+  return true
+}
+
 export async function handleOpencodeSession({
   prompt,
   thread,
   projectDirectory,
   originalMessage,
   images = [],
-  parsedCommand,
   channelId,
+  command,
 }: {
   prompt: string
   thread: ThreadChannel
   projectDirectory?: string
   originalMessage?: Message
   images?: FilePartInput[]
-  parsedCommand?: ParsedCommand
   channelId?: string
+  /** If set, uses session.command API instead of session.prompt */
+  command?: { name: string; arguments: string }
 }): Promise<{ sessionID: string; result: any; port?: number } | undefined> {
   voiceLogger.log(
     `[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
@@ -197,9 +251,15 @@ export async function handleOpencodeSession({
     return
   }
 
-  const eventsResult = await getClient().event.subscribe({
-    signal: abortController.signal,
-  })
+  // Use v2 client for event subscription (has proper types for question.asked events)
+  const clientV2 = getOpencodeClientV2(directory)
+  if (!clientV2) {
+    throw new Error(`OpenCode v2 client not found for directory: ${directory}`)
+  }
+  const eventsResult = await clientV2.event.subscribe(
+    { directory },
+    { signal: abortController.signal }
+  )
 
   if (abortController.signal.aborted) {
     sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`)
@@ -220,6 +280,7 @@ export async function handleOpencodeSession({
   let stopTyping: (() => void) | null = null
   let usedModel: string | undefined
   let usedProviderID: string | undefined
+  let usedAgent: string | undefined
   let tokensUsedInSession = 0
   let lastDisplayedContextPercentage = 0
   let modelContextLimit: number | undefined
@@ -270,7 +331,7 @@ export async function handleOpencodeSession({
   const sendPartMessage = async (part: Part) => {
     const content = formatPart(part) + '\n\n'
     if (!content.trim() || content.length === 0) {
-      discordLogger.log(`SKIP: Part ${part.id} has no content`)
+      // discordLogger.log(`SKIP: Part ${part.id} has no content`)
       return
     }
 
@@ -313,6 +374,7 @@ export async function handleOpencodeSession({
             assistantMessageId = msg.id
             usedModel = msg.modelID
             usedProviderID = msg.providerID
+            usedAgent = msg.mode
 
             if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
               if (!modelContextLimit) {
@@ -409,7 +471,7 @@ export async function handleOpencodeSession({
             )
           }
           break
-        } else if (event.type === 'permission.updated') {
+        } else if (event.type === 'permission.asked') {
           const permission = event.properties
           if (permission.sessionID !== session.id) {
             voiceLogger.log(
@@ -419,18 +481,15 @@ export async function handleOpencodeSession({
           }
 
           sessionLogger.log(
-            `Permission requested: type=${permission.type}, title=${permission.title}`,
+            `Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`,
           )
 
-          const patternStr = Array.isArray(permission.pattern)
-            ? permission.pattern.join(', ')
-            : permission.pattern || ''
+          const patternStr = permission.patterns.join(', ')
 
           const permissionMessage = await sendThreadMessage(
             thread,
             `⚠️ **Permission Required**\n\n` +
-              `**Type:** \`${permission.type}\`\n` +
-              `**Action:** ${permission.title}\n` +
+              `**Type:** \`${permission.permission}\`\n` +
               (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
               `\nUse \`/accept\` or \`/reject\` to respond.`,
           )
@@ -441,19 +500,40 @@ export async function handleOpencodeSession({
             directory,
           })
         } else if (event.type === 'permission.replied') {
-          const { permissionID, response, sessionID } = event.properties
+          const { requestID, reply, sessionID } = event.properties
           if (sessionID !== session.id) {
             continue
           }
 
           sessionLogger.log(
-            `Permission ${permissionID} replied with: ${response}`,
+            `Permission ${requestID} replied with: ${reply}`,
           )
 
           const pending = pendingPermissions.get(thread.id)
-          if (pending && pending.permission.id === permissionID) {
+          if (pending && pending.permission.id === requestID) {
             pendingPermissions.delete(thread.id)
           }
+        } else if (event.type === 'question.asked') {
+          const questionRequest = event.properties
+
+          if (questionRequest.sessionID !== session.id) {
+            sessionLogger.log(
+              `[QUESTION IGNORED] Question for different session (expected: ${session.id}, got: ${questionRequest.sessionID})`,
+            )
+            continue
+          }
+
+          sessionLogger.log(
+            `Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`,
+          )
+
+          await showAskUserQuestionDropdowns({
+            thread,
+            sessionId: session.id,
+            directory,
+            requestId: questionRequest.id,
+            input: { questions: questionRequest.questions },
+          })
         }
       }
     } catch (e) {
@@ -490,6 +570,7 @@ export async function handleOpencodeSession({
         )
         const attachCommand = port ? ` ⋅ ${session.id}` : ''
         const modelInfo = usedModel ? ` ⋅ ${usedModel}` : ''
+        const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build' ? ` ⋅ **${usedAgent}**` : ''
         let contextInfo = ''
 
         try {
@@ -504,7 +585,7 @@ export async function handleOpencodeSession({
           sessionLogger.error('Failed to fetch provider info for context percentage:', e)
         }
 
-        await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`, { flags: NOTIFY_MESSAGE_FLAGS })
+        await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}${agentInfo}`, { flags: NOTIFY_MESSAGE_FLAGS })
         sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`)
 
         // Process queued messages after completion
@@ -554,56 +635,65 @@ export async function handleOpencodeSession({
 
     stopTyping = startTyping()
 
-    let response: { data?: unknown; error?: unknown; response: Response }
-    if (parsedCommand?.isCommand) {
-      sessionLogger.log(
-        `[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`,
-      )
-      response = await getClient().session.command({
-        path: { id: session.id },
-        body: {
-          command: parsedCommand.command,
-          arguments: parsedCommand.arguments,
-        },
-        signal: abortController.signal,
-      })
-    } else {
-      voiceLogger.log(
-        `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
-      )
-      if (images.length > 0) {
-        sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
+    voiceLogger.log(
+      `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
+    )
+    // append image paths to prompt so ai knows where they are on disk
+    const promptWithImagePaths = (() => {
+      if (images.length === 0) {
+        return prompt
       }
-
-      const parts = [{ type: 'text' as const, text: prompt }, ...images]
-      sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
-
-      // Get model preference: session-level overrides channel-level
-      const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined)
-      const modelParam = (() => {
-        if (!modelPreference) {
-          return undefined
-        }
-        const [providerID, ...modelParts] = modelPreference.split('/')
-        const modelID = modelParts.join('/')
-        if (!providerID || !modelID) {
-          return undefined
-        }
-        sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`)
-        return { providerID, modelID }
-      })()
-
-      response = await getClient().session.prompt({
-        path: { id: session.id },
-        body: {
-          parts,
-          system: getOpencodeSystemMessage({ sessionId: session.id }),
-          model: modelParam,
-        },
-        signal: abortController.signal,
-      })
+      sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
+      const imagePathsList = images.map((img) => `- ${img.filename}: ${img.url}`).join('\n')
+      return `${prompt}\n\n**attached images:**\n${imagePathsList}`
+    })()
+
+    const parts = [{ type: 'text' as const, text: promptWithImagePaths }, ...images]
+    sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
+
+    // Get model preference: session-level overrides channel-level
+    const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined)
+    const modelParam = (() => {
+      if (!modelPreference) {
+        return undefined
+      }
+      const [providerID, ...modelParts] = modelPreference.split('/')
+      const modelID = modelParts.join('/')
+      if (!providerID || !modelID) {
+        return undefined
+      }
+      sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`)
+      return { providerID, modelID }
+    })()
+
+    // Get agent preference: session-level overrides channel-level
+    const agentPreference = getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined)
+    if (agentPreference) {
+      sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`)
     }
 
+    // Use session.command API for slash commands, session.prompt for regular messages
+    const response = command
+      ? await getClient().session.command({
+          path: { id: session.id },
+          body: {
+            command: command.name,
+            arguments: command.arguments,
+            agent: agentPreference,
+          },
+          signal: abortController.signal,
+        })
+      : await getClient().session.prompt({
+          path: { id: session.id },
+          body: {
+            parts,
+            system: getOpencodeSystemMessage({ sessionId: session.id }),
+            model: modelParam,
+            agent: agentPreference,
+          },
+          signal: abortController.signal,
+        })
+
     if (response.error) {
       const errorMessage = (() => {
         const err = response.error

package/src/system-message.ts

@@ -18,24 +18,6 @@ Only users with these Discord permissions can send messages to the bot:
 - Manage Server permission
 - "Kimaki" role (case-insensitive)
 
-## changing the model
-
-To change the model used by OpenCode, edit the project's \`opencode.json\` config file and set the \`model\` field:
-
-\`\`\`json
-{
-  "model": "anthropic/claude-sonnet-4-20250514"
-}
-\`\`\`
-
-Examples:
-- \`"anthropic/claude-sonnet-4-20250514"\` - Claude Sonnet 4
-- \`"anthropic/claude-opus-4-20250514"\` - Claude Opus 4
-- \`"openai/gpt-4o"\` - GPT-4o
-- \`"google/gemini-2.5-pro"\` - Gemini 2.5 Pro
-
-Format is \`provider/model-name\`. You can also set \`small_model\` for tasks like title generation.
-
 ## uploading files to discord
 
 To upload files to the Discord thread (images, screenshots, long files that would clutter the chat), run:
@@ -56,7 +38,9 @@ bunx critique web -- path/to/file1.ts path/to/file2.ts
 
 You can also show latest commit changes using:
 
-bunx critique web HEAD~1
+bunx critique web HEAD
+
+bunx critique web HEAD~1 to get the one before last
 
 Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
 
@@ -70,40 +54,9 @@ the max heading level is 3, so do not use ####
 
 headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
 
-## capitalization
-
-write casually like a discord user. never capitalize the initials of phrases or acronyms in your messages. use all lowercase instead.
-
-examples:
-- write "api" not "API"
-- write "url" not "URL"
-- write "json" not "JSON"
-- write "cli" not "CLI"
-- write "sdk" not "SDK"
-
-this makes your messages blend in naturally with how people actually type on discord.
-
-## tables
-
-discord does NOT support markdown gfm tables.
-
-so instead of using full markdown tables ALWAYS show code snippets with space aligned cells:
-
-\`\`\`
-Item        Qty   Price
-----------  ---   -----
-Apples      10    $5
-Oranges     3     $2
-\`\`\`
-
-Using code blocks will make the content use monospaced font so that space will be aligned correctly
-
-IMPORTANT: add enough space characters to align the table! otherwise the content will not look good and will be difficult to understand for the user
-
-code blocks for tables and diagrams MUST have Max length of 85 characters. otherwise the content will wrap
 
 ## diagrams
 
-you can create diagrams wrapping them in code blocks too.
+you can create diagrams wrapping them in code blocks.
 `
 }

package/src/voice-handler.ts

@@ -434,14 +434,16 @@ export async function processVoiceAttachment({
   projectDirectory,
   isNewThread = false,
   appId,
-  sessionMessages,
+  currentSessionContext,
+  lastSessionContext,
 }: {
   message: Message
   thread: ThreadChannel
   projectDirectory?: string
   isNewThread?: boolean
   appId?: string
-  sessionMessages?: string
+  currentSessionContext?: string
+  lastSessionContext?: string
 }): Promise<string | null> {
   const audioAttachment = Array.from(message.attachments.values()).find(
     (attachment) => attachment.contentType?.startsWith('audio/'),
@@ -491,13 +493,22 @@ export async function processVoiceAttachment({
     }
   }
 
-  const transcription = await transcribeAudio({
-    audio: audioBuffer,
-    prompt: transcriptionPrompt,
-    geminiApiKey,
-    directory: projectDirectory,
-    sessionMessages,
-  })
+  let transcription: string
+  try {
+    transcription = await transcribeAudio({
+      audio: audioBuffer,
+      prompt: transcriptionPrompt,
+      geminiApiKey,
+      directory: projectDirectory,
+      currentSessionContext,
+      lastSessionContext,
+    })
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error)
+    voiceLogger.error(`Transcription failed:`, error)
+    await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`)
+    return null
+  }
 
   voiceLogger.log(
     `Transcription successful: "${transcription.slice(0, 50)}${transcription.length > 50 ? '...' : ''}"`,

package/src/voice.ts

@@ -52,7 +52,8 @@ async function runGrep({
       .join('\n')
 
     return output.slice(0, 2000)
-  } catch {
+  } catch (e) {
+    voiceLogger.error('grep search failed:', e)
     return 'grep search failed'
   }
 }
@@ -304,7 +305,8 @@ export async function transcribeAudio({
   temperature,
   geminiApiKey,
   directory,
-  sessionMessages,
+  currentSessionContext,
+  lastSessionContext,
 }: {
   audio: Buffer | Uint8Array | ArrayBuffer | string
   prompt?: string
@@ -312,7 +314,8 @@ export async function transcribeAudio({
   temperature?: number
   geminiApiKey?: string
   directory?: string
-  sessionMessages?: string
+  currentSessionContext?: string
+  lastSessionContext?: string
 }): Promise<string> {
   try {
     const apiKey = geminiApiKey || process.env.GEMINI_API_KEY
@@ -338,6 +341,22 @@ export async function transcribeAudio({
 
     const languageHint = language ? `The audio is in ${language}.\n\n` : ''
 
+    // build session context section
+    const sessionContextParts: string[] = []
+    if (lastSessionContext) {
+      sessionContextParts.push(`<last_session>
+${lastSessionContext}
+</last_session>`)
+    }
+    if (currentSessionContext) {
+      sessionContextParts.push(`<current_session>
+${currentSessionContext}
+</current_session>`)
+    }
+    const sessionContextSection = sessionContextParts.length > 0
+      ? `\nSession context (use to understand references to files, functions, tools used):\n${sessionContextParts.join('\n\n')}`
+      : ''
+
     const transcriptionPrompt = `${languageHint}Transcribe this audio for a coding agent (like Claude Code or OpenCode).
 
 CRITICAL REQUIREMENT: You MUST call the "transcriptionResult" tool to complete this task.
@@ -351,30 +370,30 @@ This is a software development environment. The speaker is giving instructions t
 - File paths, function names, CLI commands, package names, API endpoints
 
 RULES:
-1. You have LIMITED tool calls - use grep/glob sparingly, call them in parallel
-2. If audio is unclear, transcribe your best interpretation
-3. If audio seems silent/empty, call transcriptionResult with "[inaudible audio]"
-4. When warned about remaining steps, STOP searching and call transcriptionResult immediately
+1. If audio is unclear, transcribe your best interpretation, interpreting words event with strong accents are present, identifying the accent being used first so you can guess what the words meawn
+2. If audio seems silent/empty, call transcriptionResult with "[inaudible audio]"
+3. Use the session context below to understand technical terms, file names, function names mentioned
 
 Common corrections (apply without tool calls):
 - "reacked" → "React", "jason" → "JSON", "get hub" → "GitHub", "no JS" → "Node.js", "dacker" → "Docker"
 
-Project context for reference:
-<context>
+Project file structure:
+<file_tree>
 ${prompt}
-</context>
-${sessionMessages ? `\nRecent session messages:\n<session_messages>\n${sessionMessages}\n</session_messages>` : ''}
+</file_tree>
+${sessionContextSection}
 
 REMEMBER: Call "transcriptionResult" tool with your transcription. This is mandatory.
 
 Note: "critique" is a CLI tool for showing diffs in the browser.`
 
-    const hasDirectory = directory && directory.trim().length > 0
+    // const hasDirectory = directory && directory.trim().length > 0
     const tools = [
       {
         functionDeclarations: [
           transcriptionResultToolDeclaration,
-          ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
+          // grep/glob disabled - was causing transcription to hang
+          // ...(hasDirectory ? [grepToolDeclaration, globToolDeclaration] : []),
         ],
       },
     ]

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Kimaki
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.