micro-models-agent 0.28.9 → 0.29.0

package/dist/tools/remember.js

@@ -0,0 +1,67 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { t } from '../i18n/index';
+import { MemoryStore } from '../modules/memory/store';
+const CATEGORIES = ['preferences', 'conventions', 'decisions', 'errors', 'facts'];
+export const rememberTool = {
+    name: 'remember',
+    description: 'Remember information across sessions. Use for user preferences, facts, conventions, decisions, or errors.',
+    tags: ['memory'],
+    parameters: {
+        type: 'object',
+        properties: {
+            category: {
+                type: 'string',
+                description: 'Memory category: preferences, conventions, decisions, errors, facts',
+                enum: CATEGORIES,
+            },
+            key: {
+                type: 'string',
+                description: 'Key name (required for preferences, e.g. "color", "language")',
+            },
+            value: {
+                type: 'string',
+                description: 'Value to store (required for preferences)',
+            },
+            entry: {
+                type: 'string',
+                description: 'Text entry to append (for conventions, decisions, errors, facts)',
+            },
+        },
+        required: ['category'],
+    },
+    handler: async (_ctx, args) => {
+        const category = String(args.category || '');
+        if (!CATEGORIES.includes(category)) {
+            return { success: false, output: t('tool.invalid_params') };
+        }
+        const memoryDir = join(homedir(), '.mma', 'memory');
+        const store = new MemoryStore(memoryDir);
+        try {
+            if (category === 'preferences') {
+                const key = String(args.key || '');
+                const value = String(args.value || '');
+                if (!key) {
+                    return { success: false, output: t('tool.remember.key_required') };
+                }
+                store.setPreference(key, value);
+                return {
+                    success: true,
+                    output: t('tool.remember.preference', { key, value }),
+                };
+            }
+            const entry = String(args.entry || '');
+            if (!entry) {
+                return { success: false, output: t('tool.remember.entry_required') };
+            }
+            store.append(category, entry);
+            return {
+                success: true,
+                output: t('tool.remember.entry', { category, entry }),
+            };
+        }
+        catch (err) {
+            return { success: true, output: t('tool.memory_error', { error: String(err) }) };
+        }
+    },
+};

package/dist/tools/scope-check.js

@@ -0,0 +1,30 @@
+import { resolve, normalize } from 'path';
+export function isPathInScope(baseDir, targetPath, scope) {
+    const baseResolved = resolve(baseDir);
+    const targetResolved = resolve(baseDir, normalize(targetPath));
+    if (!targetResolved.startsWith(baseResolved)) {
+        return { allowed: false, reason: 'Path is outside the base working directory' };
+    }
+    if (!scope)
+        return { allowed: true };
+    const isRead = scope.read_only_files.some(f => targetResolved.startsWith(resolve(baseDir, f)));
+    const isWrite = scope.allowed_files.some(f => targetResolved.startsWith(resolve(baseDir, f)));
+    if (isWrite)
+        return { allowed: true };
+    if (isRead)
+        return { allowed: true, reason: 'Read-only file' };
+    return { allowed: false, reason: 'Path is not within the allowed scope for this sub-agent' };
+}
+export function isPathWritable(baseDir, targetPath, scope) {
+    const baseResolved = resolve(baseDir);
+    const targetResolved = resolve(baseDir, normalize(targetPath));
+    if (!targetResolved.startsWith(baseResolved)) {
+        return { allowed: false, reason: 'Path is outside the base working directory' };
+    }
+    if (!scope)
+        return { allowed: true };
+    const isWrite = scope.allowed_files.some(f => targetResolved.startsWith(resolve(baseDir, f)));
+    if (isWrite)
+        return { allowed: true };
+    return { allowed: false, reason: 'Path is not within the writable scope for this sub-agent' };
+}

package/dist/tools/search-history.js

@@ -0,0 +1,64 @@
+import * as fs from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { t } from '../i18n/index';
+function searchFile(filePath, query, maxResults, results) {
+    if (!fs.existsSync(filePath))
+        return;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    for (const line of content.split('\n').filter(Boolean)) {
+        if (line.toLowerCase().includes(query)) {
+            try {
+                const entry = JSON.parse(line);
+                results.push(`[${filePath}] ${JSON.stringify(entry).slice(0, 200)}`);
+            }
+            catch { /* skip */ }
+        }
+        if (results.length >= maxResults)
+            break;
+    }
+}
+export const searchHistoryTool = {
+    name: 'search_history',
+    description: 'Search through session history for past interactions across all sessions.',
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            maxResults: { type: 'number', description: 'Maximum results (default 5)' },
+            sessionId: { type: 'string', description: 'Optional: limit search to a specific session' },
+        },
+        required: ['query'],
+    },
+    handler: async (_ctx, args) => {
+        const query = String(args.query || '').toLowerCase();
+        const maxResults = Number(args.maxResults) || 5;
+        const sessionId = args.sessionId ? String(args.sessionId) : null;
+        const sessionDir = join(homedir(), '.mma', 'sessions');
+        const results = [];
+        try {
+            if (!fs.existsSync(sessionDir)) {
+                return { success: true, output: t('tool.no_sessions_dir', { dir: sessionDir }) };
+            }
+            const entries = fs.readdirSync(sessionDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (sessionId && entry.name !== sessionId)
+                    continue;
+                const historyFile = join(sessionDir, entry.name, 'history.jsonl');
+                searchFile(historyFile, query, maxResults, results);
+                if (results.length >= maxResults)
+                    break;
+            }
+            if (results.length === 0) {
+                return { success: true, output: t('tool.no_history', { query }) };
+            }
+            return { success: true, output: t('tool.history_results', { query, results: results.join('\n') }) };
+        }
+        catch (err) {
+            return { success: true, output: t('tool.history_error', { error: String(err) }) };
+        }
+    },
+};

package/dist/tools/subagent.js

@@ -0,0 +1,142 @@
+import { t } from "../i18n/index";
+import { Agent } from "../core/agent";
+import { ContextManager } from "../modules/context/manager";
+import { HallucinationDetector } from "../modules/hallucination/detector";
+import { PluginManager } from "../modules/plugins/manager";
+import { logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+export const subagentTool = {
+    name: "subagent",
+    description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
+    tags: ["code"],
+    parameters: {
+        type: "object",
+        properties: {
+            task: {
+                type: "string",
+                description: "Task description for the sub-agent",
+            },
+            context: {
+                type: "string",
+                description: "Optional context or constraints",
+            },
+            expert_tag: {
+                type: "string",
+                description: "Expert tag for tool filtering and model selection",
+            },
+            allowed_files: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files/directories the sub-agent can read and write",
+            },
+            read_only_files: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files/directories the sub-agent can read but not write",
+            },
+            shared_context: {
+                type: "string",
+                description: "Shared context/rules passed to the sub-agent",
+            },
+            max_tokens: {
+                type: "number",
+                description: "Maximum tokens for the sub-agent response",
+            },
+            tool_tags: {
+                type: "array",
+                items: { type: "string" },
+                description: "Tool tags to expose to the sub-agent",
+            },
+        },
+        required: ["task"],
+    },
+    handler: async (ctx, args) => {
+        const task = String(args.task || "");
+        const context = String(args.context || "");
+        if (!task) {
+            return { success: false, output: t("tool.name_or_task") };
+        }
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Security check: limit recursion depth
+        const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
+        const currentDepth = ctx.recursionDepth ?? 0;
+        if (currentDepth >= maxDepth) {
+            logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, task);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum sub-agent recursion depth (${maxDepth}) exceeded`,
+            };
+        }
+        const scope = args.allowed_files || args.read_only_files
+            ? {
+                allowed_files: args.allowed_files || [],
+                read_only_files: args.read_only_files || [],
+            }
+            : ctx.scope;
+        const toolTags = args.tool_tags ? args.tool_tags : undefined;
+        if (!ctx.llmProvider || !ctx.toolExecutor) {
+            return {
+                success: false,
+                output: "Sub-agent cannot run: missing llmProvider or toolExecutor in context",
+            };
+        }
+        // Defensive guard: if the caller requested specific tool tags but none of the
+        // registered tools match, the sub-agent would have zero tools and would
+        // hallucinate instead of acting. Warn the caller so it can correct the tags.
+        if (toolTags && toolTags.length > 0) {
+            const matched = ctx.toolExecutor.getToolDefinitions(toolTags);
+            if (matched.length === 0) {
+                return {
+                    success: false,
+                    output: `[SECURITY BLOCKED] No tools match the requested tool_tags: [${toolTags.join(", ")}]. Check the subagent tool_tags parameter and retry with valid tags (e.g. "file", "code", "shell", "research").`,
+                };
+            }
+        }
+        try {
+            const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
+            const subPluginManager = new PluginManager();
+            const hallucinationDetector = new HallucinationDetector();
+            const systemPrompt = {
+                content: `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`,
+                priority: "critical",
+                essential: true,
+                estimatedTokens: 100,
+            };
+            const subDeps = {
+                config: ctx.config,
+                llmProvider: ctx.llmProvider,
+                toolExecutor: ctx.toolExecutor,
+                pluginManager: subPluginManager,
+                contextManager: subContextManager,
+                hallucinationDetector,
+                logger: ctx.logger,
+                baseDir: ctx.baseDir,
+                scope,
+                toolTags,
+                promptBlocks: [systemPrompt],
+                recursionDepth: currentDepth + 1, // Increment recursion depth for sub-agent
+            };
+            const subAgent = new Agent(subDeps);
+            const fullTask = context ? `${task}\n\nContext: ${context}` : task;
+            const result = await subAgent.run(fullTask);
+            if (result.success) {
+                return {
+                    success: true,
+                    output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    output: `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`,
+                };
+            }
+        }
+        catch (e) {
+            return { success: false, output: `Sub-agent error: ${e.message}` };
+        }
+    },
+};

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/user-input.js

@@ -0,0 +1,123 @@
+import * as readline from "readline";
+import { t } from "../i18n/index";
+/** Index returned by askChoice when the user picks the "custom answer" entry. */
+export const CUSTOM_INDEX = -1;
+/**
+ * Parse user input like "1" or "1,3" into 0-based option indexes.
+ * Returns null on invalid input (empty, non-numeric, out of range,
+ * duplicates, or multiple values when multiple is false).
+ */
+export function parseSelection(input, optionCount, multiple) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    const parts = trimmed.split(",").map((p) => p.trim());
+    if (!multiple && parts.length > 1)
+        return null;
+    const indexes = [];
+    for (const part of parts) {
+        if (!/^\d+$/.test(part))
+            return null;
+        const idx = Number(part) - 1;
+        if (idx < 0 || idx >= optionCount)
+            return null;
+        if (indexes.includes(idx))
+            return null;
+        indexes.push(idx);
+    }
+    return indexes.length ? indexes : null;
+}
+/** Render question + numbered option list as a single string. */
+export function formatMenu(question, options, opts = {}) {
+    const lines = [question];
+    options.forEach((opt, i) => {
+        lines.push(`  [${i + 1}] ${opt.label} — ${opt.description}`);
+    });
+    if (opts.allowCustom) {
+        lines.push(`  [${options.length + 1}] ${t("tool.user_input.custom_option")}`);
+    }
+    return lines.join("\n");
+}
+/** Prompt text for the choice input. */
+export function choicePrompt(optionCount, multiple) {
+    return multiple
+        ? t("tool.user_input.choice_multiple")
+        : t("tool.user_input.choice_single", { max: optionCount });
+}
+function createRl() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+function promptLine(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => resolve(answer));
+    });
+}
+/** Free-text question. Returns trimmed answer (may be empty). */
+export async function askText(question) {
+    const rl = createRl();
+    try {
+        const answer = await promptLine(rl, `${question} `);
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Choice question: shows a numbered menu and waits for a valid selection.
+ * Returns selected 0-based indexes; CUSTOM_INDEX marks the custom entry.
+ * Re-asks until the input is valid.
+ */
+export async function askChoice(question, options, opts = {}) {
+    const multiple = opts.multiple ?? false;
+    const entryCount = options.length + (opts.allowCustom ? 1 : 0);
+    const customEntry = options.length; // index of the custom entry, if enabled
+    const rl = createRl();
+    try {
+        console.log(formatMenu(question, options, opts));
+        for (;;) {
+            const answer = await promptLine(rl, choicePrompt(entryCount, multiple));
+            const parsed = parseSelection(answer, entryCount, multiple);
+            if (parsed) {
+                return parsed.map((i) => opts.allowCustom && i === customEntry ? CUSTOM_INDEX : i);
+            }
+            console.log(t("tool.user_input.invalid"));
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * High-level helper used by the question tool.
+ * - No options: free-text input, returns [text] or [] when empty.
+ * - With options: returns selected labels; custom entry resolves to typed text.
+ */
+export async function askUser(question, opts = {}) {
+    const header = [opts.progress, opts.header].filter(Boolean).join(" — ");
+    const text = header ? `${header}\n${question}` : question;
+    if (!opts.options || opts.options.length === 0) {
+        const answer = await askText(text);
+        return answer ? [answer] : [];
+    }
+    const allowCustom = opts.custom ?? true;
+    const indexes = await askChoice(text, opts.options, {
+        multiple: opts.multiple,
+        allowCustom,
+    });
+    const labels = [];
+    for (const idx of indexes) {
+        if (idx === CUSTOM_INDEX) {
+            const custom = await askText(t("tool.user_input.custom_prompt"));
+            if (custom)
+                labels.push(custom);
+        }
+        else {
+            labels.push(opts.options[idx].label);
+        }
+    }
+    return labels;
+}

package/dist/tools/web-browse.js

@@ -0,0 +1,57 @@
+import { t } from '../i18n/index';
+import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
+import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+import { MAX_PREVIEW_LINES } from './preview';
+const MAX_CHARS = 3000;
+export const webBrowseTool = {
+    name: 'web_browse',
+    description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS} chars).`,
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to fetch' },
+        },
+        required: ['url'],
+    },
+    handler: async (ctx, args) => {
+        const url = String(args.url || '');
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
+            : ctx.config.security?.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000) });
+            const text = await response.text();
+            const stripped = text
+                .replace(/<script[\s\S]*?<\/script>/gi, '')
+                .replace(/<style[\s\S]*?<\/style>/gi, '')
+                .replace(/<[^>]+>/g, '')
+                .replace(/&[^;]+;/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            // Log successful network request
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+            const maxLen = securityConfig?.maxResponseSize || MAX_CHARS;
+            let content = stripped.length > maxLen ? stripped.slice(0, maxLen) + t('file.truncated') : stripped;
+            const lines = content.split('\n');
+            if (lines.length > MAX_PREVIEW_LINES) {
+                content = lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
+            }
+            return { success: true, output: content || t('file.empty_page') };
+        }
+        catch (err) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
+            return { success: false, output: t('error.fetch_url_failed', { url: sanitizeUrl(url), message: err.message }) };
+        }
+    },
+};

package/dist/tools/web-fetch.js

@@ -0,0 +1,72 @@
+import { t } from '../i18n/index';
+import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
+import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+import { DEFAULT_SECURITY_CONFIG } from '../config/security';
+import { MAX_PREVIEW_LINES } from './preview';
+const MAX_CHARS = 5000;
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&[^;]+;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export const webFetchTool = {
+    name: 'web_fetch',
+    description: 'Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages.',
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to fetch' },
+        },
+        required: ['url'],
+    },
+    handler: async (ctx, args) => {
+        const url = String(args.url);
+        // Get session-specific security config
+        const config = ctx.config || {};
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(config, ctx.sessionContext).network
+            : config.security?.network || DEFAULT_SECURITY_CONFIG.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000) });
+            if (!response.ok) {
+                return { success: false, output: t('error.http', { status: response.status, statusText: response.statusText }) };
+            }
+            const contentType = response.headers.get('content-type') || '';
+            const text = await response.text();
+            const cleaned = contentType.includes('html') ? stripHtml(text) : text;
+            // Log successful network request
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+            if (cleaned.length > (securityConfig?.maxResponseSize || MAX_CHARS)) {
+                let content = cleaned.slice(0, securityConfig?.maxResponseSize || MAX_CHARS) + t('file.truncated');
+                const lines = content.split('\n');
+                if (lines.length > MAX_PREVIEW_LINES) {
+                    content = lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
+                }
+                return { success: true, output: content };
+            }
+            const lines = cleaned.split('\n');
+            if (lines.length > MAX_PREVIEW_LINES) {
+                return { success: true, output: lines.slice(0, MAX_PREVIEW_LINES).join('\n') + `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)` };
+            }
+            return { success: true, output: cleaned || t('file.empty_page') };
+        }
+        catch (e) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${e.message}`);
+            return { success: false, output: t('error.fetch_failed', { message: e.message }) };
+        }
+    },
+};

package/dist/tools/web-search.js

@@ -0,0 +1,59 @@
+import { t } from '../i18n/index';
+import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
+import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+export const webSearchTool = {
+    name: 'web_search',
+    description: 'Search the web for information. Returns search results with titles and snippets.',
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            numResults: { type: 'number', description: 'Number of results (default 5)' },
+        },
+        required: ['query'],
+    },
+    handler: async (ctx, args) => {
+        const query = String(args.query || '');
+        const numResults = Number(args.numResults) || 5;
+        // Build search URL
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
+            : ctx.config.security?.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Search URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 10000) });
+            const html = await response.text();
+            const results = [];
+            const snippetRegex = /<a[^>]+class="result__a"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+            let match;
+            let count = 0;
+            while ((match = snippetRegex.exec(html)) !== null && count < numResults) {
+                const title = match[1].replace(/<[^>]+>/g, '').trim();
+                const snippet = match[2].replace(/<[^>]+>/g, '').trim();
+                results.push(`${title}: ${snippet}`);
+                count++;
+            }
+            // Log successful network request
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Results: ${results.length}`);
+            if (results.length === 0) {
+                return { success: true, output: t('tool.no_results', { query }) };
+            }
+            return { success: true, output: t('tool.search_results', { query, results: results.join('\n') }) };
+        }
+        catch (err) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
+            return { success: false, output: t('error.search_failed', { message: err.message }) };
+        }
+    },
+};