skimpyclaw 0.3.14 → 0.4.0

package/dist/api.js

@@ -11,6 +11,7 @@ import { redactSecrets } from './security.js';
 import { readAuditTraces } from './audit.js';
 import { getUsageSummary, readUsageRecords } from './usage.js';
 import { getAllCodeAgents, getCodeAgent, cancelCodeAgent } from './tools.js';
+import { withCodeAgentModelLabel } from './code-agents/utils.js';
 import { listApprovals, getApproval, approveRequest, denyRequest } from './exec-approval.js';
 import { getDigests, getDigest, deleteDigest, updateArticleReadStatus } from './digests.js';
 import { loadSkills } from './skills.js';
@@ -22,15 +23,13 @@ import { initHeartbeat, stopHeartbeat } from './heartbeat.js';
 import { initActiveChannel, stopActiveChannel, startActiveChannel } from './channels.js';
 import { setCodeAgentConfig } from './tools.js';
 import { resolveModelSelection } from './model-selection.js';
+import { readSessionEntriesFromFile } from './sessions.js';
+import { getAgentProfileByAlias, listAgentProfiles, listThreadAgentBindings, normalizeThreadAgentAlias, removeAgentProfile, setAgentProfileModel, setAgentProfilePrompt, setAgentProfileThinking, upsertAgentProfile, } from './channels/discord/thread-agents.js';
 const DEFAULT_MODEL_ALIASES = {
-    'claude-fast': 'anthropic/claude-haiku-4-5',
-    'claude-think': 'anthropic/claude-sonnet-4-6',
-    'claude-opus': 'anthropic/claude-opus-4-6',
     'codex5.1': 'codex/gpt-5.1-codex',
     'codex5.2': 'codex/gpt-5.2-codex',
     'codex5.3': 'codex/gpt-5.3-codex',
-    minimax: 'minimax/MiniMax-M2.5',
-    kimi: 'kimi/kimi-for-coding',
+    'codex5.5': 'codex/gpt-5.5',
 };
 function validateFilename(filename) {
     return !filename.includes('..') && filename === basename(filename);
@@ -42,6 +41,23 @@ function validateSkillName(name) {
 function getSkillsDir(cfg) {
     return cfg.skills?.directory || join(homedir(), '.skimpyclaw', 'skills');
 }
+const THINKING_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh']);
+function parseThinkingLevel(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/^x[-_ ]?high$/, 'xhigh');
+    if (normalized === 'off')
+        return 'none';
+    return THINKING_LEVELS.has(normalized) ? normalized : undefined;
+}
+function configuredAgentsSummary(config) {
+    return Object.fromEntries(Object.entries(config.agents.list).map(([id, agent]) => [id, {
+            name: agent.identity?.name || id,
+            emoji: agent.identity?.emoji || '',
+            model: agent.model,
+            thinking: agent.thinking,
+        }]));
+}
 function resolveCronPromptPath(inputPath) {
     const trimmed = inputPath.trim();
     if (!trimmed || !trimmed.endsWith('.md') || trimmed.includes('\0'))
@@ -160,18 +176,7 @@ export function registerDashboardAPI(fastify, config) {
             if (channelFilter && channel !== channelFilter)
                 return null;
             try {
-                const content = readFileSync(join(sessionsDir, file), 'utf-8');
-                const lines = content.split('\n').filter(Boolean);
-                const entries = lines
-                    .map((line) => {
-                    try {
-                        return JSON.parse(line);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter((v) => Boolean(v));
+                const entries = readSessionEntriesFromFile(join(sessionsDir, file));
                 const last = entries[entries.length - 1];
                 const preview = last?.user || last?.assistant || '';
                 return {
@@ -205,21 +210,14 @@ export function registerDashboardAPI(fastify, config) {
             const offsetRaw = Number.parseInt(request.query.offset || '0', 10);
             const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(limitRaw, 1), 500) : 80;
             const offset = Number.isFinite(offsetRaw) ? Math.max(offsetRaw, 0) : 0;
-            const content = readFileSync(filePath, 'utf-8');
-            const lines = content.split('\n').filter(Boolean);
+            const entries = readSessionEntriesFromFile(filePath);
             const messages = [];
-            for (const line of lines) {
-                try {
-                    const entry = JSON.parse(line);
-                    const ts = entry.ts || new Date().toISOString();
-                    if (entry.user)
-                        messages.push({ ts, role: 'user', content: entry.user });
-                    if (entry.assistant)
-                        messages.push({ ts, role: 'assistant', content: entry.assistant });
-                }
-                catch {
-                    // Ignore malformed lines
-                }
+            for (const entry of entries) {
+                const ts = entry.ts || new Date().toISOString();
+                if (entry.user)
+                    messages.push({ ts, role: 'user', content: entry.user });
+                if (entry.assistant)
+                    messages.push({ ts, role: 'assistant', content: entry.assistant });
             }
             const total = messages.length;
             const end = Math.max(0, total - offset);
@@ -385,7 +383,7 @@ export function registerDashboardAPI(fastify, config) {
             : DEFAULT_MODEL_ALIASES;
         const currentModel = getCurrentModel()
             || runtimeConfig.agents?.list?.[runtimeConfig.agents?.default]?.model
-            || 'claude-opus';
+            || 'anthropic/claude-opus-4-7';
         return {
             current: currentModel,
             aliases: mergedAliases,
@@ -404,6 +402,87 @@ export function registerDashboardAPI(fastify, config) {
         setCurrentModel(selection.resolved);
         return { model: selection.resolved };
     });
+    // --- Discord Agent Profiles ---
+    fastify.get('/api/dashboard/agent-profiles', async () => {
+        return {
+            profiles: listAgentProfiles(),
+            bindings: listThreadAgentBindings(),
+            configuredAgents: configuredAgentsSummary(runtimeConfig),
+            modelAliases: runtimeConfig.models?.aliases || DEFAULT_MODEL_ALIASES,
+        };
+    });
+    fastify.post('/api/dashboard/agent-profiles', async (request, reply) => {
+        const alias = normalizeThreadAgentAlias(request.body?.alias);
+        const agentId = request.body?.agentId?.trim();
+        if (!alias)
+            return reply.code(400).send({ error: 'Invalid alias' });
+        if (!agentId || !runtimeConfig.agents.list[agentId]) {
+            return reply.code(400).send({ error: 'Unknown configured agent' });
+        }
+        try {
+            const profile = upsertAgentProfile({ alias, agentId, createdBy: 'dashboard' });
+            return { profile };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            return reply.code(400).send({ error: msg });
+        }
+    });
+    fastify.put('/api/dashboard/agent-profiles/:alias', async (request, reply) => {
+        const alias = normalizeThreadAgentAlias(request.params.alias);
+        if (!alias)
+            return reply.code(400).send({ error: 'Invalid alias' });
+        const existing = getAgentProfileByAlias(alias);
+        if (!existing)
+            return reply.code(404).send({ error: 'Agent profile not found' });
+        const body = request.body || {};
+        if (typeof body.agentId === 'string') {
+            const agentId = body.agentId.trim();
+            if (!agentId || !runtimeConfig.agents.list[agentId]) {
+                return reply.code(400).send({ error: 'Unknown configured agent' });
+            }
+            upsertAgentProfile({ alias, agentId, createdBy: existing.createdBy || 'dashboard' });
+        }
+        if ('model' in body) {
+            const modelInput = typeof body.model === 'string' ? body.model.trim() : '';
+            if (modelInput) {
+                const selection = resolveModelSelection(modelInput, runtimeConfig);
+                if (!selection.ok || !selection.resolved) {
+                    return reply.code(400).send({ error: selection.error || 'Invalid model selection' });
+                }
+                setAgentProfileModel(alias, selection.resolved);
+            }
+            else {
+                setAgentProfileModel(alias, undefined);
+            }
+        }
+        if ('thinking' in body) {
+            const thinkingInput = typeof body.thinking === 'string' ? body.thinking.trim() : '';
+            if (thinkingInput) {
+                const thinking = parseThinkingLevel(thinkingInput);
+                if (!thinking)
+                    return reply.code(400).send({ error: 'Invalid effort' });
+                setAgentProfileThinking(alias, thinking);
+            }
+            else {
+                setAgentProfileThinking(alias, undefined);
+            }
+        }
+        if ('promptOverlay' in body) {
+            const promptOverlay = typeof body.promptOverlay === 'string' ? body.promptOverlay : '';
+            setAgentProfilePrompt(alias, promptOverlay);
+        }
+        return { profile: getAgentProfileByAlias(alias) };
+    });
+    fastify.delete('/api/dashboard/agent-profiles/:alias', async (request, reply) => {
+        const alias = normalizeThreadAgentAlias(request.params.alias);
+        if (!alias)
+            return reply.code(400).send({ error: 'Invalid alias' });
+        const deleted = removeAgentProfile(alias);
+        if (!deleted)
+            return reply.code(404).send({ error: 'Agent profile not found' });
+        return { deleted: true };
+    });
     // --- Templates ---
     fastify.get('/api/dashboard/templates/:agentId', async (request, reply) => {
         const { agentId } = request.params;
@@ -651,9 +730,6 @@ export function registerDashboardAPI(fastify, config) {
         const features = {
             telegram: runtimeConfig.channels.telegram?.enabled ?? false,
             discord: runtimeConfig.channels.discord?.enabled ?? false,
-            browser: Boolean(runtimeConfig.channels.telegram?.tools?.browser?.enabled
-                || runtimeConfig.channels.discord?.tools?.browser?.enabled
-                || runtimeConfig.heartbeat?.tools?.browser?.enabled),
             voice: Boolean(runtimeConfig.voice?.enabled),
         };
         // Check which env vars are set vs missing by reading raw config for ${VAR} refs
@@ -687,7 +763,7 @@ export function registerDashboardAPI(fastify, config) {
     });
     // --- Code Agents (Multi-Agent) ---
     fastify.get('/api/dashboard/code-agents', async () => {
-        const agents = getAllCodeAgents();
+        const agents = getAllCodeAgents().map(withCodeAgentModelLabel);
         return { agents };
     });
     fastify.get('/api/dashboard/code-agents/:id', async (request, reply) => {
@@ -696,7 +772,7 @@ export function registerDashboardAPI(fastify, config) {
         if (!agent) {
             return reply.code(404).send({ error: 'Code agent not found' });
         }
-        return agent;
+        return withCodeAgentModelLabel(agent);
     });
     fastify.post('/api/dashboard/code-agents/:id/cancel', async (request, reply) => {
         const { id } = request.params;

package/dist/channels/discord/attachments.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Discord attachment processing — extensible framework for extracting text
+ * content from user-uploaded files (txt, pdf, etc.) and injecting it into
+ * the model context.
+ */
+import type { Attachment } from 'discord.js';
+/** Maximum attachment size in bytes (2 MB) */
+export declare const MAX_ATTACHMENT_BYTES: number;
+/** Maximum extracted text length in characters (100 KB) */
+export declare const MAX_TEXT_CHARS = 100000;
+export interface AttachmentResult {
+    /** Whether extraction succeeded */
+    ok: boolean;
+    /** Extracted text (present when ok=true) */
+    text?: string;
+    /** Human-readable error (present when ok=false) */
+    error?: string;
+    /** Original filename */
+    filename: string;
+}
+/** Handler for a specific file type */
+export interface AttachmentHandler {
+    /** File extensions this handler supports (lowercase, without dot) */
+    extensions: string[];
+    /** MIME type prefixes this handler supports */
+    mimeTypes: string[];
+    /** Extract text from the attachment buffer */
+    extract(buffer: Buffer, filename: string): Promise<string>;
+}
+/**
+ * Register a custom attachment handler. Handlers added later take priority
+ * over earlier ones when extensions overlap.
+ */
+export declare function registerHandler(handler: AttachmentHandler): void;
+/** List supported file extensions across all registered handlers. */
+export declare function supportedExtensions(): string[];
+/**
+ * Check if a Discord attachment is a "document" type we can extract text from
+ * (i.e. not an image or audio, which have their own handling paths).
+ */
+export declare function isDocumentAttachment(attachment: Attachment): boolean;
+/**
+ * Process a Discord attachment: fetch, validate, extract text.
+ * Returns a result object — never throws.
+ */
+export declare function processAttachment(attachment: Attachment): Promise<AttachmentResult>;
+/**
+ * Process multiple attachments, returning results for each.
+ */
+export declare function processAttachments(attachments: Attachment[]): Promise<AttachmentResult[]>;

package/dist/channels/discord/attachments.js

@@ -0,0 +1,137 @@
+/**
+ * Discord attachment processing — extensible framework for extracting text
+ * content from user-uploaded files (txt, pdf, etc.) and injecting it into
+ * the model context.
+ */
+import { PDFParse } from 'pdf-parse';
+// ── Constants ────────────────────────────────────────────────────────
+/** Maximum attachment size in bytes (2 MB) */
+export const MAX_ATTACHMENT_BYTES = 2 * 1024 * 1024;
+/** Maximum extracted text length in characters (100 KB) */
+export const MAX_TEXT_CHARS = 100_000;
+/** Fetch timeout in milliseconds */
+const FETCH_TIMEOUT_MS = 15_000;
+// ── Built-in handlers ────────────────────────────────────────────────
+const textHandler = {
+    extensions: ['txt', 'md', 'csv', 'json', 'xml', 'yaml', 'yml', 'log', 'ini', 'cfg', 'conf', 'toml', 'env', 'sh', 'bash', 'zsh', 'py', 'js', 'ts', 'jsx', 'tsx', 'html', 'css', 'sql', 'rb', 'go', 'rs', 'java', 'kt', 'swift', 'c', 'cpp', 'h', 'hpp'],
+    mimeTypes: ['text/'],
+    extract: async (buffer) => buffer.toString('utf-8'),
+};
+const pdfHandler = {
+    extensions: ['pdf'],
+    mimeTypes: ['application/pdf'],
+    extract: async (buffer, filename) => {
+        const parser = new PDFParse({ data: buffer });
+        try {
+            const result = await parser.getText();
+            const text = result.text?.trim();
+            if (!text) {
+                throw new Error(`PDF "${filename}" contains no extractable text (may be image-only).`);
+            }
+            return text;
+        }
+        finally {
+            await parser.destroy().catch(() => { });
+        }
+    },
+};
+// ── Registry ─────────────────────────────────────────────────────────
+const handlers = [textHandler, pdfHandler];
+/**
+ * Register a custom attachment handler. Handlers added later take priority
+ * over earlier ones when extensions overlap.
+ */
+export function registerHandler(handler) {
+    handlers.push(handler);
+}
+/** List supported file extensions across all registered handlers. */
+export function supportedExtensions() {
+    const exts = new Set();
+    for (const h of handlers) {
+        for (const ext of h.extensions)
+            exts.add(ext);
+    }
+    return [...exts].sort();
+}
+function findHandler(filename, contentType) {
+    const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+    // Search in reverse so later-registered handlers win
+    for (let i = handlers.length - 1; i >= 0; i--) {
+        const h = handlers[i];
+        if (h.extensions.includes(ext))
+            return h;
+        if (contentType && h.mimeTypes.some(prefix => contentType.startsWith(prefix)))
+            return h;
+    }
+    return undefined;
+}
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Check if a Discord attachment is a "document" type we can extract text from
+ * (i.e. not an image or audio, which have their own handling paths).
+ */
+export function isDocumentAttachment(attachment) {
+    const contentType = attachment.contentType ?? '';
+    if (contentType.startsWith('image/') || contentType.startsWith('audio/') || contentType.startsWith('voice/')) {
+        return false;
+    }
+    const filename = attachment.name ?? 'unknown';
+    return findHandler(filename, contentType) !== undefined;
+}
+/**
+ * Process a Discord attachment: fetch, validate, extract text.
+ * Returns a result object — never throws.
+ */
+export async function processAttachment(attachment) {
+    const filename = attachment.name ?? 'unknown';
+    try {
+        // Size check
+        if (attachment.size > MAX_ATTACHMENT_BYTES) {
+            return {
+                ok: false,
+                error: `File "${filename}" is too large (${(attachment.size / 1024 / 1024).toFixed(1)} MB). Maximum is ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB.`,
+                filename,
+            };
+        }
+        // Find handler
+        const handler = findHandler(filename, attachment.contentType ?? null);
+        if (!handler) {
+            return {
+                ok: false,
+                error: `Unsupported file type: "${filename}". Supported extensions: ${supportedExtensions().map(e => `.${e}`).join(', ')}`,
+                filename,
+            };
+        }
+        // Fetch with timeout
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        let buffer;
+        try {
+            const response = await fetch(attachment.url, { signal: controller.signal });
+            if (!response.ok) {
+                return { ok: false, error: `Failed to download "${filename}" (HTTP ${response.status}).`, filename };
+            }
+            buffer = Buffer.from(await response.arrayBuffer());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        // Extract text
+        let text = await handler.extract(buffer, filename);
+        // Truncate if needed
+        if (text.length > MAX_TEXT_CHARS) {
+            text = text.slice(0, MAX_TEXT_CHARS) + `\n\n[... truncated at ${MAX_TEXT_CHARS.toLocaleString()} characters]`;
+        }
+        return { ok: true, text, filename };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        return { ok: false, error: `Error processing "${filename}": ${msg}`, filename };
+    }
+}
+/**
+ * Process multiple attachments, returning results for each.
+ */
+export async function processAttachments(attachments) {
+    return Promise.all(attachments.map(processAttachment));
+}

package/dist/channels/discord/delegation.d.ts

@@ -0,0 +1,5 @@
+import { type Client } from 'discord.js';
+import type { Config } from '../../types.js';
+import type { ExecuteToolContext } from '../../tools/execute-context.js';
+import type { NormalizedDelegateToAgentInput } from '../../tools/agent-delegation.js';
+export declare function createDiscordAgentDelegateHandler(getClient: () => Client | null): ((input: NormalizedDelegateToAgentInput, config: Config, context?: ExecuteToolContext) => Promise<string>);

package/dist/channels/discord/delegation.js

@@ -0,0 +1,136 @@
+import { ChannelType } from 'discord.js';
+import { runAgentTurn } from '../../agent.js';
+import { getCurrentModel, getCurrentThinking } from '../../gateway.js';
+import { bindThreadAgent, getAgentProfileByAlias, } from './thread-agents.js';
+import { addToHistory, getDiscordToolConfig, getHistory, sendLongTextToChannel, startTypingIndicatorForChannel, } from './utils.js';
+import { buildThreadUrl } from './threads.js';
+function formatThreadAgentThreadName(alias, taskText) {
+    const task = (taskText || '')
+        .replace(/https?:\/\/\S+\/pull\/(\d+)\S*/g, '#$1')
+        .replace(/https?:\/\/\S+\/issues\/(\d+)\S*/g, '#$1')
+        .replace(/https?:\/\/\S+/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const base = task || 'agent';
+    const maxTaskLength = Math.max(10, 96 - alias.length);
+    const suffix = base.length > maxTaskLength ? `${base.slice(0, maxTaskLength - 3).trim()}...` : base;
+    return `${alias}: ${suffix}`.slice(0, 100);
+}
+function isThreadLike(channel) {
+    return Boolean(channel.isThread?.());
+}
+function canStartThreadFromMessage(message) {
+    return typeof message.startThread === 'function';
+}
+function truncateTask(value, maxChars) {
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars - 3).trim()}...`;
+}
+function buildRunContext(context, threadAgent, parentChannelId) {
+    const depth = (context?.delegationDepth ?? 0) + 1;
+    return {
+        userId: context?.approverUserId,
+        sessionId: threadAgent.threadId,
+        channel: 'discord',
+        trigger: 'discord',
+        metadata: {
+            username: context?.approverUsername,
+            isDm: false,
+            discordThreadId: threadAgent.threadId,
+            discordChannelId: parentChannelId,
+            threadAgentAlias: threadAgent.alias,
+            threadAgentId: threadAgent.agentId,
+            threadAgentModel: threadAgent.model,
+            threadAgentThinking: threadAgent.thinking,
+            thinkingOverride: threadAgent.thinking ?? getCurrentThinking(),
+            threadAgentPromptOverlay: threadAgent.promptOverlay,
+            delegationDepth: depth,
+            delegatedFromAgentAlias: context?.threadAgentAlias,
+        },
+    };
+}
+async function runDelegatedAgent(thread, parentChannelId, threadAgent, task, config, context) {
+    await sendLongTextToChannel(thread, `Task delegated to @${threadAgent.alias}:\n${task}`);
+    const stopTyping = startTypingIndicatorForChannel(thread);
+    try {
+        const key = `channel:${thread.id}`;
+        const history = await getHistory(key);
+        const response = await runAgentTurn(threadAgent.agentId, task, config, threadAgent.model || getCurrentModel(), getDiscordToolConfig(config), history, buildRunContext(context, threadAgent, parentChannelId));
+        await addToHistory(key, task, response);
+        await sendLongTextToChannel(thread, response);
+        return response;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        await sendLongTextToChannel(thread, `Error: ${msg}`);
+        throw err;
+    }
+    finally {
+        stopTyping();
+    }
+}
+async function resolveDelegationParentChannel(client, context) {
+    const sourceChannelId = context?.discordChannelId || context?.channelTargetId || context?.sessionId;
+    if (!sourceChannelId)
+        return null;
+    const channel = await client.channels.fetch(String(sourceChannelId)).catch(() => null);
+    if (!channel)
+        return null;
+    if (isThreadLike(channel)) {
+        const parentId = channel.parentId;
+        if (!parentId)
+            return null;
+        const parent = await client.channels.fetch(parentId).catch(() => null);
+        return parent && 'send' in parent ? parent : null;
+    }
+    const channelType = channel.type;
+    const supportsThreads = channelType === ChannelType.GuildText || channelType === ChannelType.GuildAnnouncement;
+    if (!supportsThreads || !('send' in channel))
+        return null;
+    return channel;
+}
+export function createDiscordAgentDelegateHandler(getClient) {
+    return async (input, config, context) => {
+        const client = getClient();
+        if (!client)
+            return 'Error: Discord client is not available.';
+        const profile = getAgentProfileByAlias(input.alias);
+        if (!profile)
+            return `Error: No Discord agent profile found for @${input.alias}.`;
+        if (!config.agents.list[profile.agentId]) {
+            return `Error: Agent profile @${profile.alias} points to missing configured agent "${profile.agentId}".`;
+        }
+        const parentChannel = await resolveDelegationParentChannel(client, context);
+        if (!parentChannel) {
+            return 'Error: Could not find a Discord server channel where I can create a delegated agent thread.';
+        }
+        const preview = truncateTask(input.task, 300);
+        const starter = await parentChannel.send(`Delegating to @${profile.alias}:\n${preview}`);
+        if (!canStartThreadFromMessage(starter)) {
+            return 'Error: Discord did not allow creating a thread for this delegated agent.';
+        }
+        const thread = await starter.startThread({
+            name: formatThreadAgentThreadName(profile.alias, input.task),
+            autoArchiveDuration: 1440,
+        });
+        const threadAgent = bindThreadAgent({
+            threadId: thread.id,
+            alias: profile.alias,
+            createdBy: context?.approverUserId || 'agent-delegation',
+            guildId: thread.guildId,
+            channelId: thread.parentId ?? parentChannel.id,
+        });
+        const url = buildThreadUrl(thread.guildId, thread.id);
+        const runner = runDelegatedAgent(thread, thread.parentId ?? parentChannel.id, threadAgent, input.task, config, context);
+        if (input.wait) {
+            await runner;
+        }
+        else {
+            void runner.catch((err) => {
+                console.error('[discord-agent-delegation] Delegated agent failed:', err);
+            });
+        }
+        return url
+            ? `Delegated to @${profile.alias}: ${url}`
+            : `Delegated to @${profile.alias} in thread ${thread.id}.`;
+    };
+}