kimaki 0.4.38 → 0.4.40

package/dist/markdown.js

@@ -1,10 +1,20 @@
 // 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 * as errore from 'errore';
+import { createTaggedError } from 'errore';
 import * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';
 import { createLogger } from './logger.js';
+import { SessionNotFoundError, MessagesNotFoundError } from './errors.js';
+// Generic error for unexpected exceptions in async operations
+class UnexpectedError extends createTaggedError({
+    name: 'UnexpectedError',
+    message: '$message',
+}) {
+}
 const markdownLogger = createLogger('MARKDOWN');
 export class ShareMarkdown {
     client;
@@ -14,7 +24,7 @@ export class ShareMarkdown {
     /**
      * Generate a markdown representation of a session
      * @param options Configuration options
-     * @returns Markdown string representation of the session
+     * @returns Error or markdown string
      */
     async generate(options) {
         const { sessionID, includeSystemInfo, lastAssistantOnly } = options;
@@ -23,7 +33,7 @@ export class ShareMarkdown {
             path: { id: sessionID },
         });
         if (!sessionResponse.data) {
-            throw new Error(`Session ${sessionID} not found`);
+            return new SessionNotFoundError({ sessionId: sessionID });
         }
         const session = sessionResponse.data;
         // Get all messages
@@ -31,7 +41,7 @@ export class ShareMarkdown {
             path: { id: sessionID },
         });
         if (!messagesResponse.data) {
-            throw new Error(`No messages found for session ${sessionID}`);
+            return new MessagesNotFoundError({ sessionId: sessionID });
         }
         const messages = messagesResponse.data;
         // If lastAssistantOnly, filter to only the last assistant message
@@ -211,98 +221,103 @@ export class ShareMarkdown {
  * Includes system prompt (optional), user messages, assistant text,
  * and tool calls in compact form (name + params only, no output).
  */
-export async function getCompactSessionContext({ client, sessionId, includeSystemPrompt = false, maxMessages = 20, }) {
-    try {
-        const messagesResponse = await client.session.messages({
-            path: { id: sessionId },
-        });
-        const messages = messagesResponse.data || [];
-        const lines = [];
-        // 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.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)');
+export function getCompactSessionContext({ client, sessionId, includeSystemPrompt = false, maxMessages = 20, }) {
+    return errore.tryAsync({
+        try: async () => {
+            const messagesResponse = await client.session.messages({
+                path: { id: sessionId },
+            });
+            const messages = messagesResponse.data || [];
+            const lines = [];
+            // 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.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('');
                     }
-                    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' && 'text' in p)
-                    .map((p) => ('text' in p ? 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' && 'text' in p && !p.synthetic && p.text)
-                    .map((p) => ('text' in p ? p.text : ''))
-                    .filter(Boolean);
-                if (textParts.length > 0) {
-                    lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`);
-                    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' && 'text' in p)
+                        .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
+                        .filter(Boolean);
+                    if (textParts.length > 0) {
+                        lines.push(`[User]: ${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;
+                else if (msg.info.role === 'assistant') {
+                    // Get assistant text parts (non-synthetic, non-empty)
+                    const textParts = (msg.parts || [])
+                        .filter((p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text)
+                        .map((p) => ('text' in p ? 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) => 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}`);
                         }
-                        const input = part.state?.input || {};
-                        // 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}=${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 '';
-    }
+            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 async function getLastSessionId({ client, excludeSessionId, }) {
-    try {
-        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 null;
-    }
+export function getLastSessionId({ client, excludeSessionId, }) {
+    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/dist/markdown.test.js

@@ -1,6 +1,7 @@
 import { test, expect, beforeAll, afterAll } from 'vitest';
 import { spawn } from 'child_process';
 import { OpencodeClient } from '@opencode-ai/sdk';
+import * as errore from 'errore';
 import { ShareMarkdown, getCompactSessionContext } from './markdown.js';
 let serverProcess;
 let client;
@@ -100,10 +101,12 @@ test('generate markdown from first available session', async () => {
     // Create markdown exporter
     const exporter = new ShareMarkdown(client);
     // Generate markdown with system info
-    const markdown = await exporter.generate({
+    const markdownResult = await exporter.generate({
         sessionID,
         includeSystemInfo: true,
     });
+    expect(errore.isOk(markdownResult)).toBe(true);
+    const markdown = errore.unwrap(markdownResult);
     console.log(`Generated markdown length: ${markdown.length} characters`);
     // Basic assertions
     expect(markdown).toBeTruthy();
@@ -233,12 +236,14 @@ test('generate markdown from multiple sessions', async () => {
 // test for getCompactSessionContext - disabled in CI since it requires a specific session
 test.skipIf(process.env.CI)('getCompactSessionContext generates compact format', async () => {
     const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM';
-    const context = await getCompactSessionContext({
+    const contextResult = await getCompactSessionContext({
         client,
         sessionId,
         includeSystemPrompt: true,
         maxMessages: 15,
     });
+    expect(errore.isOk(contextResult)).toBe(true);
+    const context = errore.unwrap(contextResult);
     console.log(`Generated compact context length: ${context.length} characters`);
     expect(context).toBeTruthy();
     expect(context.length).toBeGreaterThan(0);
@@ -248,12 +253,14 @@ test.skipIf(process.env.CI)('getCompactSessionContext generates compact format',
 });
 test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
     const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM';
-    const context = await getCompactSessionContext({
+    const contextResult = await getCompactSessionContext({
         client,
         sessionId,
         includeSystemPrompt: false,
         maxMessages: 10,
     });
+    expect(errore.isOk(contextResult)).toBe(true);
+    const context = errore.unwrap(contextResult);
     console.log(`Generated compact context (no system) length: ${context.length} characters`);
     expect(context).toBeTruthy();
     // should NOT have system prompt

package/dist/message-formatting.js

@@ -3,7 +3,9 @@
 // handles file attachments, and provides tool summary generation.
 import fs from 'node:fs';
 import path from 'node:path';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
+import { FetchError } from './errors.js';
 const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments');
 const logger = createLogger('FORMATTING');
 /**
@@ -56,18 +58,18 @@ export async function getTextAttachments(message) {
         return '';
     }
     const textContents = await Promise.all(textAttachments.map(async (attachment) => {
-        try {
-            const response = await fetch(attachment.url);
-            if (!response.ok) {
-                return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`;
-            }
-            const text = await response.text();
-            return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`;
+        const response = await errore.tryAsync({
+            try: () => fetch(attachment.url),
+            catch: (e) => new FetchError({ url: attachment.url, cause: e }),
+        });
+        if (response instanceof Error) {
+            return `<attachment filename="${attachment.name}" error="${response.message}" />`;
         }
-        catch (error) {
-            const errMsg = error instanceof Error ? error.message : String(error);
-            return `<attachment filename="${attachment.name}" error="${errMsg}" />`;
+        if (!response.ok) {
+            return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`;
         }
+        const text = await response.text();
+        return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`;
     }));
     return textContents.join('\n\n');
 }
@@ -84,27 +86,28 @@ export async function getFileAttachments(message) {
         fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true });
     }
     const results = await Promise.all(fileAttachments.map(async (attachment) => {
-        try {
-            const response = await fetch(attachment.url);
-            if (!response.ok) {
-                logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`);
-                return null;
-            }
-            const buffer = Buffer.from(await response.arrayBuffer());
-            const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`);
-            fs.writeFileSync(localPath, buffer);
-            logger.log(`Downloaded attachment to ${localPath}`);
-            return {
-                type: 'file',
-                mime: attachment.contentType || 'application/octet-stream',
-                filename: attachment.name,
-                url: localPath,
-            };
+        const response = await errore.tryAsync({
+            try: () => fetch(attachment.url),
+            catch: (e) => new FetchError({ url: attachment.url, cause: e }),
+        });
+        if (response instanceof Error) {
+            logger.error(`Error downloading attachment ${attachment.name}:`, response.message);
+            return null;
         }
-        catch (error) {
-            logger.error(`Error downloading attachment ${attachment.name}:`, error);
+        if (!response.ok) {
+            logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`);
             return null;
         }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`);
+        fs.writeFileSync(localPath, buffer);
+        logger.log(`Downloaded attachment to ${localPath}`);
+        return {
+            type: 'file',
+            mime: attachment.contentType || 'application/octet-stream',
+            filename: attachment.name,
+            url: localPath,
+        };
     }));
     return results.filter((r) => r !== null);
 }
@@ -157,9 +160,9 @@ export function getToolSummaryText(part) {
     if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
         return '';
     }
+    // Task tool display is handled via subtask part in session-handler (shows label like explore-1)
     if (part.tool === 'task') {
-        const description = part.state.input?.description || '';
-        return description ? `_${escapeInlineMarkdown(description)}_` : '';
+        return '';
     }
     if (part.tool === 'skill') {
         const name = part.state.input?.name || '';
@@ -197,10 +200,15 @@ export function formatTodoList(part) {
     const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1);
     return `${num} **${escapeInlineMarkdown(content)}**`;
 }
-export function formatPart(part) {
+export function formatPart(part, prefix) {
+    const pfx = prefix ? `${prefix}: ` : '';
     if (part.type === 'text') {
         if (!part.text?.trim())
             return '';
+        // For subtask text, always use bullet with prefix
+        if (prefix) {
+            return `⬥ ${pfx}${part.text.trim()}`;
+        }
         const trimmed = part.text.trimStart();
         const firstChar = trimmed[0] || '';
         const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|'];
@@ -213,28 +221,33 @@ export function formatPart(part) {
     if (part.type === 'reasoning') {
         if (!part.text?.trim())
             return '';
-        return `┣ thinking`;
+        return `┣ ${pfx}thinking`;
     }
     if (part.type === 'file') {
-        return `📄 ${part.filename || 'File'}`;
+        return prefix ? `📄 ${pfx}${part.filename || 'File'}` : `📄 ${part.filename || 'File'}`;
     }
     if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
         return '';
     }
     if (part.type === 'agent') {
-        return `┣ agent ${part.id}`;
+        return `┣ ${pfx}agent ${part.id}`;
     }
     if (part.type === 'snapshot') {
-        return `┣ snapshot ${part.snapshot}`;
+        return `┣ ${pfx}snapshot ${part.snapshot}`;
     }
     if (part.type === 'tool') {
         if (part.tool === 'todowrite') {
-            return formatTodoList(part);
+            const formatted = formatTodoList(part);
+            return prefix && formatted ? `┣ ${pfx}${formatted}` : formatted;
         }
         // Question tool is handled via Discord dropdowns, not text
         if (part.tool === 'question') {
             return '';
         }
+        // Task tool display is handled in session-handler with proper label
+        if (part.tool === 'task') {
+            return '';
+        }
         if (part.state.status === 'pending') {
             return '';
         }
@@ -270,7 +283,7 @@ export function formatPart(part) {
             }
             return '┣';
         })();
-        return `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
+        return `${icon} ${pfx}${part.tool} ${toolTitle} ${summaryText}`.trim();
     }
     logger.warn('Unknown part type:', part);
     return '';

package/dist/opencode.js

@@ -1,12 +1,15 @@
 // OpenCode server process manager.
 // Spawns and maintains OpenCode API servers per project directory,
 // handles automatic restarts on failure, and provides typed SDK clients.
+// Uses errore for type-safe error handling.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import net from 'node:net';
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { createOpencodeClient as createOpencodeClientV2, } from '@opencode-ai/sdk/v2';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
+import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
 const opencodeLogger = createLogger('OPENCODE');
 const opencodeServers = new Map();
 const serverRetryCount = new Map();
@@ -30,42 +33,33 @@ async function getOpenPort() {
 }
 async function waitForServer(port, maxAttempts = 30) {
     for (let i = 0; i < maxAttempts; i++) {
-        try {
-            const endpoints = [
-                `http://127.0.0.1:${port}/api/health`,
-                `http://127.0.0.1:${port}/`,
-                `http://127.0.0.1:${port}/api`,
-            ];
-            for (const endpoint of endpoints) {
-                try {
-                    const response = await fetch(endpoint);
-                    if (response.status < 500) {
-                        return true;
-                    }
-                    const body = await response.text();
-                    // Fatal errors that won't resolve with retrying
-                    if (body.includes('BunInstallFailedError')) {
-                        throw new Error(`Server failed to start: ${body.slice(0, 200)}`);
-                    }
-                }
-                catch (e) {
-                    // Re-throw fatal errors
-                    if (e.message?.includes('Server failed to start')) {
-                        throw e;
-                    }
-                }
+        const endpoints = [
+            `http://127.0.0.1:${port}/api/health`,
+            `http://127.0.0.1:${port}/`,
+            `http://127.0.0.1:${port}/api`,
+        ];
+        for (const endpoint of endpoints) {
+            const response = await errore.tryAsync({
+                try: () => fetch(endpoint),
+                catch: (e) => new FetchError({ url: endpoint, cause: e }),
+            });
+            if (response instanceof Error) {
+                // Connection refused or other transient errors - continue polling
+                opencodeLogger.debug(`Server polling attempt failed: ${response.message}`);
+                continue;
             }
-        }
-        catch (e) {
-            // Re-throw fatal errors that won't resolve with retrying
-            if (e.message?.includes('Server failed to start')) {
-                throw e;
+            if (response.status < 500) {
+                return true;
+            }
+            const body = await response.text();
+            // Fatal errors that won't resolve with retrying
+            if (body.includes('BunInstallFailedError')) {
+                return new ServerStartError({ port, reason: body.slice(0, 200) });
             }
-            opencodeLogger.debug(`Server polling attempt failed: ${e.message}`);
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-    throw new Error(`Server did not start on port ${port} after ${maxAttempts} seconds`);
+    return new ServerStartError({ port, reason: `Server did not start after ${maxAttempts} seconds` });
 }
 export async function initializeOpencodeForDirectory(directory) {
     const existing = opencodeServers.get(directory);
@@ -74,17 +68,20 @@ export async function initializeOpencodeForDirectory(directory) {
         return () => {
             const entry = opencodeServers.get(directory);
             if (!entry?.client) {
-                throw new Error(`OpenCode server for directory "${directory}" is in an error state (no client available)`);
+                throw new ServerNotReadyError({ directory });
             }
             return entry.client;
         };
     }
     // Verify directory exists and is accessible before spawning
-    try {
-        fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK);
-    }
-    catch {
-        throw new Error(`Directory does not exist or is not accessible: ${directory}`);
+    const accessCheck = errore.tryFn({
+        try: () => {
+            fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK);
+        },
+        catch: () => new DirectoryNotAccessibleError({ directory }),
+    });
+    if (accessCheck instanceof Error) {
+        return accessCheck;
     }
     const port = await getOpenPort();
     const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
@@ -127,8 +124,10 @@ export async function initializeOpencodeForDirectory(directory) {
             if (retryCount < 5) {
                 serverRetryCount.set(directory, retryCount + 1);
                 opencodeLogger.log(`Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`);
-                initializeOpencodeForDirectory(directory).catch((e) => {
-                    opencodeLogger.error(`Failed to restart opencode server:`, e);
+                initializeOpencodeForDirectory(directory).then((result) => {
+                    if (result instanceof Error) {
+                        opencodeLogger.error(`Failed to restart opencode server:`, result);
+                    }
                 });
             }
             else {
@@ -139,18 +138,16 @@ export async function initializeOpencodeForDirectory(directory) {
             serverRetryCount.delete(directory);
         }
     });
-    try {
-        await waitForServer(port);
-        opencodeLogger.log(`Server ready on port ${port}`);
-    }
-    catch (e) {
+    const waitResult = await waitForServer(port);
+    if (waitResult instanceof Error) {
         // Dump buffered logs on failure
         opencodeLogger.error(`Server failed to start for ${directory}:`);
         for (const line of logBuffer) {
             opencodeLogger.error(`  ${line}`);
         }
-        throw e;
+        return waitResult;
     }
+    opencodeLogger.log(`Server ready on port ${port}`);
     const baseUrl = `http://127.0.0.1:${port}`;
     const fetchWithTimeout = (request) => fetch(request, {
         // @ts-ignore
@@ -173,7 +170,7 @@ export async function initializeOpencodeForDirectory(directory) {
     return () => {
         const entry = opencodeServers.get(directory);
         if (!entry?.client) {
-            throw new Error(`OpenCode server for directory "${directory}" is in an error state (no client available)`);
+            throw new ServerNotReadyError({ directory });
         }
         return entry.client;
     };