kimaki 0.4.38 → 0.4.39

package/dist/cli.js

@@ -9,6 +9,7 @@ import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDis
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
@@ -256,8 +257,8 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             .toJSON());
     }
     // Add agent-specific quick commands like /plan-agent, /build-agent
-    // Filter to primary/all mode agents (same as /agent command shows)
-    const primaryAgents = agents.filter((a) => a.mode === 'primary' || a.mode === 'all');
+    // Filter to primary/all mode agents (same as /agent command shows), excluding hidden agents
+    const primaryAgents = agents.filter((a) => (a.mode === 'primary' || a.mode === 'all') && !a.hidden);
     for (const agent of primaryAgents) {
         const sanitizedName = sanitizeAgentName(agent.name);
         const commandName = `${sanitizedName}-agent`;
@@ -432,7 +433,12 @@ async function run({ restart, addChannels }) {
     // This is the biggest startup bottleneck (can take 1-30 seconds to spawn and wait for ready)
     const currentDir = process.cwd();
     s.start('Starting OpenCode server...');
-    const opencodePromise = initializeOpencodeForDirectory(currentDir);
+    const opencodePromise = initializeOpencodeForDirectory(currentDir).then((result) => {
+        if (errore.isError(result)) {
+            throw new Error(result.message);
+        }
+        return result;
+    });
     s.message('Connecting to Discord...');
     const discordClient = await createDiscordClient();
     const guilds = [];

package/dist/commands/abort.js

@@ -5,6 +5,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { abortControllers } from '../session-handler.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('ABORT');
 export async function handleAbortCommand({ command }) {
     const channel = command.channel;
@@ -51,13 +52,21 @@ export async function handleAbortCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    const existingController = abortControllers.get(sessionId);
+    if (existingController) {
+        existingController.abort(new Error('User requested abort'));
+        abortControllers.delete(sessionId);
+    }
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.reply({
+            content: `Failed to abort: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
     try {
-        const existingController = abortControllers.get(sessionId);
-        if (existingController) {
-            existingController.abort(new Error('User requested abort'));
-            abortControllers.delete(sessionId);
-        }
-        const getClient = await initializeOpencodeForDirectory(directory);
         await getClient().session.abort({
             path: { id: sessionId },
         });

package/dist/commands/add-project.js

@@ -6,6 +6,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { createProjectChannels } from '../channel-management.js';
 import { createLogger } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
+import * as errore from 'errore';
 const logger = createLogger('ADD-PROJECT');
 export async function handleAddProjectCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
@@ -18,6 +19,10 @@ export async function handleAddProjectCommand({ command, appId }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
+        if (errore.isError(getClient)) {
+            await command.editReply(getClient.message);
+            return;
+        }
         const projectsResponse = await getClient().project.list({});
         if (!projectsResponse.data) {
             await command.editReply('Failed to fetch projects');
@@ -60,6 +65,10 @@ export async function handleAddProjectAutocomplete({ interaction, appId, }) {
     try {
         const currentDir = process.cwd();
         const getClient = await initializeOpencodeForDirectory(currentDir);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const projectsResponse = await getClient().project.list({});
         if (!projectsResponse.data) {
             await interaction.respond([]);

package/dist/commands/agent.js

@@ -6,6 +6,7 @@ import { getDatabase, setChannelAgent, setSessionAgent, clearSessionModel, runMo
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const agentLogger = createLogger('AGENT');
 const pendingAgentContexts = new Map();
 /**
@@ -102,6 +103,10 @@ export async function handleAgentCommand({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (errore.isError(getClient)) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
         const agentsResponse = await getClient().app.agents({
             query: { directory: context.dir },
         });
@@ -110,7 +115,10 @@ export async function handleAgentCommand({ interaction, appId, }) {
             return;
         }
         const agents = agentsResponse.data
-            .filter((a) => a.mode === 'primary' || a.mode === 'all')
+            .filter((agent) => {
+            const hidden = agent.hidden;
+            return (agent.mode === 'primary' || agent.mode === 'all') && !hidden;
+        })
             .slice(0, 25);
         if (agents.length === 0) {
             await interaction.editReply({ content: 'No primary agents available' });
@@ -202,6 +210,10 @@ export async function handleQuickAgentCommand({ command, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (errore.isError(getClient)) {
+            await command.editReply({ content: getClient.message });
+            return;
+        }
         const agentsResponse = await getClient().app.agents({
             query: { directory: context.dir },
         });

package/dist/commands/fork.js

@@ -5,6 +5,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const sessionLogger = createLogger('SESSION');
 const forkLogger = createLogger('FORK');
 export async function handleForkCommand(interaction) {
@@ -50,8 +51,14 @@ export async function handleForkCommand(interaction) {
     // Defer reply before API calls to avoid 3-second timeout
     await interaction.deferReply({ ephemeral: true });
     const sessionId = row.session_id;
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await interaction.editReply({
+            content: `Failed to load messages: ${getClient.message}`,
+        });
+        return;
+    }
     try {
-        const getClient = await initializeOpencodeForDirectory(directory);
         const messagesResponse = await getClient().session.messages({
             path: { id: sessionId },
         });
@@ -120,8 +127,12 @@ export async function handleForkSelectMenu(interaction) {
         return;
     }
     await interaction.deferReply({ ephemeral: false });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await interaction.editReply(`Failed to fork session: ${getClient.message}`);
+        return;
+    }
     try {
-        const getClient = await initializeOpencodeForDirectory(directory);
         const forkResponse = await getClient().session.fork({
             path: { id: sessionId },
             body: { messageID: selectedMessageId },

package/dist/commands/model.js

@@ -6,6 +6,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { abortAndRetrySession } from '../session-handler.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const modelLogger = createLogger('MODEL');
 // Store context by hash to avoid customId length limits (Discord max: 100 chars)
 const pendingModelContexts = new Map();
@@ -77,6 +78,10 @@ export async function handleModelCommand({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
         const providersResponse = await getClient().provider.list({
             query: { directory: projectDirectory },
         });
@@ -162,6 +167,13 @@ export async function handleProviderSelectMenu(interaction) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (errore.isError(getClient)) {
+            await interaction.editReply({
+                content: getClient.message,
+                components: [],
+            });
+            return;
+        }
         const providersResponse = await getClient().provider.list({
             query: { directory: context.dir },
         });

package/dist/commands/remove-project.js

@@ -1,5 +1,6 @@
 // /remove-project command - Remove Discord channels for a project.
 import path from 'node:path';
+import * as errore from 'errore';
 import { getDatabase } from '../database.js';
 import { createLogger } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
@@ -25,20 +26,27 @@ export async function handleRemoveProjectCommand({ command, appId }) {
         const deletedChannels = [];
         const failedChannels = [];
         for (const { channel_id, channel_type } of channels) {
-            try {
-                const channel = await guild.channels.fetch(channel_id).catch(() => null);
-                if (channel) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (errore.isError(channel)) {
+                logger.error(`Failed to fetch channel ${channel_id}:`, channel);
+                failedChannels.push(`${channel_type}: ${channel_id}`);
+                continue;
+            }
+            if (channel) {
+                try {
                     await channel.delete(`Removed by /remove-project command`);
                     deletedChannels.push(`${channel_type}: ${channel_id}`);
                 }
-                else {
-                    // Channel doesn't exist in this guild or was already deleted
-                    deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
+                catch (error) {
+                    logger.error(`Failed to delete channel ${channel_id}:`, error);
+                    failedChannels.push(`${channel_type}: ${channel_id}`);
                 }
             }
-            catch (error) {
-                logger.error(`Failed to delete channel ${channel_id}:`, error);
-                failedChannels.push(`${channel_type}: ${channel_id}`);
+            else {
+                deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
             }
         }
         // Remove from database
@@ -76,14 +84,16 @@ export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
         // Filter to only channels that exist in this guild
         const projectsInGuild = [];
         for (const { directory, channel_id } of allChannels) {
-            try {
-                const channel = await guild.channels.fetch(channel_id).catch(() => null);
-                if (channel) {
-                    projectsInGuild.push({ directory, channelId: channel_id });
-                }
-            }
-            catch {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (errore.isError(channel)) {
                 // Channel not in this guild, skip
+                continue;
+            }
+            if (channel) {
+                projectsInGuild.push({ directory, channelId: channel_id });
             }
         }
         const projects = projectsInGuild

package/dist/commands/resume.js

@@ -7,6 +7,7 @@ import { sendThreadMessage, resolveTextChannel, getKimakiMetadata } from '../dis
 import { extractTagsArrays } from '../xml.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('RESUME');
 export async function handleResumeCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
@@ -41,6 +42,10 @@ export async function handleResumeCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await command.editReply(getClient.message);
+            return;
+        }
         const sessionResponse = await getClient().session.get({
             path: { id: sessionId },
         });
@@ -111,6 +116,10 @@ export async function handleResumeAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const sessionsResponse = await getClient().session.list();
         if (!sessionsResponse.data) {
             await interaction.respond([]);

package/dist/commands/session.js

@@ -8,6 +8,7 @@ import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { extractTagsArrays } from '../xml.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('SESSION');
 export async function handleSessionCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
@@ -44,6 +45,10 @@ export async function handleSessionCommand({ command, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await command.editReply(getClient.message);
+            return;
+        }
         const files = filesString
             .split(',')
             .map((f) => f.trim())
@@ -102,6 +107,10 @@ async function handleAgentAutocomplete({ interaction, appId }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const agentsResponse = await getClient().app.agents({
             query: { directory: projectDirectory },
         });
@@ -165,6 +174,10 @@ export async function handleSessionAutocomplete({ interaction, appId, }) {
     }
     try {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (errore.isError(getClient)) {
+            await interaction.respond([]);
+            return;
+        }
         const response = await getClient().find.files({
             query: {
                 query: currentQuery || '',

package/dist/commands/share.js

@@ -4,6 +4,7 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('SHARE');
 export async function handleShareCommand({ command }) {
     const channel = command.channel;
@@ -50,8 +51,16 @@ export async function handleShareCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.reply({
+            content: `Failed to share session: ${getClient.message}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
     try {
-        const getClient = await initializeOpencodeForDirectory(directory);
         const response = await getClient().session.share({
             path: { id: sessionId },
         });

package/dist/commands/undo-redo.js

@@ -4,6 +4,7 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
+import * as errore from 'errore';
 const logger = createLogger('UNDO-REDO');
 export async function handleUndoCommand({ command }) {
     const channel = command.channel;
@@ -50,9 +51,13 @@ export async function handleUndoCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to undo: ${getClient.message}`);
+        return;
+    }
     try {
-        await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
-        const getClient = await initializeOpencodeForDirectory(directory);
         // Fetch messages to find the last assistant message
         const messagesResponse = await getClient().session.messages({
             path: { id: sessionId },
@@ -133,9 +138,13 @@ export async function handleRedoCommand({ command }) {
         return;
     }
     const sessionId = row.session_id;
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await command.editReply(`Failed to redo: ${getClient.message}`);
+        return;
+    }
     try {
-        await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
-        const getClient = await initializeOpencodeForDirectory(directory);
         // Check if session has reverted state
         const sessionResponse = await getClient().session.get({
             path: { id: sessionId },

package/dist/database.js

@@ -4,6 +4,7 @@
 import Database from 'better-sqlite3';
 import fs from 'node:fs';
 import path from 'node:path';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
 import { getDataDir } from './config.js';
 const dbLogger = createLogger('DB');
@@ -11,11 +12,14 @@ let db = null;
 export function getDatabase() {
     if (!db) {
         const dataDir = getDataDir();
-        try {
-            fs.mkdirSync(dataDir, { recursive: true });
-        }
-        catch (error) {
-            dbLogger.error(`Failed to create data directory ${dataDir}:`, error);
+        const mkdirError = errore.tryFn({
+            try: () => {
+                fs.mkdirSync(dataDir, { recursive: true });
+            },
+            catch: (e) => e,
+        });
+        if (errore.isError(mkdirError)) {
+            dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message);
         }
         const dbPath = path.join(dataDir, 'discord-sessions.db');
         dbLogger.log(`Opening database at: ${dbPath}`);

package/dist/discord-bot.js

@@ -18,6 +18,7 @@ export { getOpencodeSystemMessage } from './system-message.js';
 export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { ChannelType, Client, Events, GatewayIntentBits, Partials, PermissionsBitField, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
+import * as errore from 'errore';
 import { extractTagsArrays } from './xml.js';
 import { createLogger } from './logger.js';
 import { setGlobalDispatcher, Agent } from 'undici';
@@ -89,11 +90,12 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
             if (message.partial) {
                 discordLogger.log(`Fetching partial message ${message.id}`);
-                try {
-                    await message.fetch();
-                }
-                catch (error) {
-                    discordLogger.log(`Failed to fetch partial message ${message.id}:`, error);
+                const fetched = await errore.tryAsync({
+                    try: () => message.fetch(),
+                    catch: (e) => e,
+                });
+                if (errore.isError(fetched)) {
+                    discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message);
                     return;
                 }
             }
@@ -173,28 +175,39 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (projectDirectory) {
                     try {
                         const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        if (errore.isError(getClient)) {
+                            voiceLogger.error(`[SESSION] Failed to initialize OpenCode client:`, getClient.message);
+                            throw new Error(getClient.message);
+                        }
                         const client = getClient();
                         // get current session context (without system prompt, it would be duplicated)
                         if (row.session_id) {
-                            currentSessionContext = await getCompactSessionContext({
+                            const result = await getCompactSessionContext({
                                 client,
                                 sessionId: row.session_id,
                                 includeSystemPrompt: false,
                                 maxMessages: 15,
                             });
+                            if (errore.isOk(result)) {
+                                currentSessionContext = result;
+                            }
                         }
                         // get last session context (with system prompt for project context)
-                        const lastSessionId = await getLastSessionId({
+                        const lastSessionResult = await getLastSessionId({
                             client,
                             excludeSessionId: row.session_id,
                         });
+                        const lastSessionId = errore.unwrapOr(lastSessionResult, null);
                         if (lastSessionId) {
-                            lastSessionContext = await getCompactSessionContext({
+                            const result = await getCompactSessionContext({
                                 client,
                                 sessionId: lastSessionId,
                                 includeSystemPrompt: true,
                                 maxMessages: 10,
                             });
+                            if (errore.isOk(result)) {
+                                lastSessionContext = result;
+                            }
                         }
                     }
                     catch (e) {

package/dist/errors.js

@@ -0,0 +1,110 @@
+// TaggedError definitions for type-safe error handling with errore.
+// Errors are grouped by category: infrastructure, domain, and validation.
+// Use errore.matchError() for exhaustive error handling in command handlers.
+import * as errore from 'errore';
+// ═══════════════════════════════════════════════════════════════════════════
+// INFRASTRUCTURE ERRORS - Server, filesystem, external services
+// ═══════════════════════════════════════════════════════════════════════════
+export class DirectoryNotAccessibleError extends errore.TaggedError('DirectoryNotAccessibleError')() {
+    constructor(args) {
+        super({ ...args, message: `Directory does not exist or is not accessible: ${args.directory}` });
+    }
+}
+export class ServerStartError extends errore.TaggedError('ServerStartError')() {
+    constructor(args) {
+        super({ ...args, message: `Server failed to start on port ${args.port}: ${args.reason}` });
+    }
+}
+export class ServerNotFoundError extends errore.TaggedError('ServerNotFoundError')() {
+    constructor(args) {
+        super({ ...args, message: `OpenCode server not found for directory: ${args.directory}` });
+    }
+}
+export class ServerNotReadyError extends errore.TaggedError('ServerNotReadyError')() {
+    constructor(args) {
+        super({
+            ...args,
+            message: `OpenCode server for directory "${args.directory}" is in an error state (no client available)`,
+        });
+    }
+}
+export class ApiKeyMissingError extends errore.TaggedError('ApiKeyMissingError')() {
+    constructor(args) {
+        super({ ...args, message: `${args.service} API key is required` });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// DOMAIN ERRORS - Sessions, messages, transcription
+// ═══════════════════════════════════════════════════════════════════════════
+export class SessionNotFoundError extends errore.TaggedError('SessionNotFoundError')() {
+    constructor(args) {
+        super({ ...args, message: `Session ${args.sessionId} not found` });
+    }
+}
+export class SessionCreateError extends errore.TaggedError('SessionCreateError')() {
+}
+export class MessagesNotFoundError extends errore.TaggedError('MessagesNotFoundError')() {
+    constructor(args) {
+        super({ ...args, message: `No messages found for session ${args.sessionId}` });
+    }
+}
+export class TranscriptionError extends errore.TaggedError('TranscriptionError')() {
+    constructor(args) {
+        super({ ...args, message: `Transcription failed: ${args.reason}` });
+    }
+}
+export class GrepSearchError extends errore.TaggedError('GrepSearchError')() {
+    constructor(args) {
+        super({ ...args, message: `Grep search failed for pattern: ${args.pattern}` });
+    }
+}
+export class GlobSearchError extends errore.TaggedError('GlobSearchError')() {
+    constructor(args) {
+        super({ ...args, message: `Glob search failed for pattern: ${args.pattern}` });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION ERRORS - Input validation, format checks
+// ═══════════════════════════════════════════════════════════════════════════
+export class InvalidAudioFormatError extends errore.TaggedError('InvalidAudioFormatError')() {
+    constructor() {
+        super({ message: 'Invalid audio format' });
+    }
+}
+export class EmptyTranscriptionError extends errore.TaggedError('EmptyTranscriptionError')() {
+    constructor() {
+        super({ message: 'Model returned empty transcription' });
+    }
+}
+export class NoResponseContentError extends errore.TaggedError('NoResponseContentError')() {
+    constructor() {
+        super({ message: 'No response content from model' });
+    }
+}
+export class NoToolResponseError extends errore.TaggedError('NoToolResponseError')() {
+    constructor() {
+        super({ message: 'No valid tool responses' });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// NETWORK ERRORS - Fetch and HTTP
+// ═══════════════════════════════════════════════════════════════════════════
+export class FetchError extends errore.TaggedError('FetchError')() {
+    constructor(args) {
+        const causeMsg = args.cause instanceof Error ? args.cause.message : String(args.cause);
+        super({ ...args, message: `Fetch failed for ${args.url}: ${causeMsg}` });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// API ERRORS - External service responses
+// ═══════════════════════════════════════════════════════════════════════════
+export class DiscordApiError extends errore.TaggedError('DiscordApiError')() {
+    constructor(args) {
+        super({ ...args, message: `Discord API error: ${args.status}${args.body ? ` - ${args.body}` : ''}` });
+    }
+}
+export class OpenCodeApiError extends errore.TaggedError('OpenCodeApiError')() {
+    constructor(args) {
+        super({ ...args, message: `OpenCode API error (${args.status})${args.body ? `: ${args.body}` : ''}` });
+    }
+}