@yvhitxcel/opencode-remote 0.16.2 → 0.17.0

package/dist/opencode/client.js

@@ -11,6 +11,57 @@ import { homedir } from 'os';
 const CONFIG_DIR = join(homedir(), '.opencode-remote');
 const CONFIG_FILE = join(CONFIG_DIR, '.env');
 
+const threadModels = new Map();
+const recentModels = [];
+let rawDebugEnabled = false;
+let thinkVisibleEnabled = false;
+
+export function setRawDebug(enabled) {
+    rawDebugEnabled = enabled;
+    console.log(`[rawDebug] ${enabled ? 'ON' : 'OFF'}`);
+}
+export function isRawDebug() {
+    return rawDebugEnabled || process.env.DEBUG_RAW === '1';
+}
+export function setThinkVisible(enabled) {
+    thinkVisibleEnabled = enabled;
+    console.log(`[think] ${enabled ? 'ON' : 'OFF'}`);
+}
+export function isThinkVisible() {
+    return thinkVisibleEnabled;
+}
+export function setThreadModel(threadId, modelStr) {
+    if (!modelStr || !modelStr.includes('/')) {
+        threadModels.delete(threadId);
+        return null;
+    }
+    const parts = modelStr.split('/');
+    const entry = { providerID: parts[0], modelID: parts.slice(1).join('/') };
+    threadModels.set(threadId, entry);
+    pushRecent(entry);
+    return entry;
+}
+
+export function getThreadModel(threadId) {
+    return threadModels.get(threadId);
+}
+
+export function getRecentModels() {
+    return [...recentModels];
+}
+
+export function pushRecentModel(entry) {
+    pushRecent(entry);
+}
+
+function pushRecent(entry) {
+    const key = `${entry.providerID}/${entry.modelID}`;
+    const idx = recentModels.findIndex(e => `${e.providerID}/${e.modelID}` === key);
+    if (idx !== -1) recentModels.splice(idx, 1);
+    recentModels.unshift(entry);
+    if (recentModels.length > 5) recentModels.length = 5;
+}
+
 // Find opencode.exe binary
 function findOpenCodeExe() {
     const isWindows = platform() === 'win32';
@@ -174,7 +225,6 @@ let opencodeInstance = null;
 let opencodeServer = null;
 let lastStdoutTime = 0;
 let lastStdoutLine = '';
-let lastReportedStatus = '';
 const PORTS_TO_TRY = [4096, 4097, 4098];
 
 // TCP-level port probe: true = occupied, false = free
@@ -190,7 +240,7 @@ function probeTCP(port, timeoutMs = 2000) {
 }
 
 async function tryConnectPort(port, timeoutMs = 5000) {
-    const { createOpencodeClient } = await import('@opencode-ai/sdk');
+    const { createOpencodeClient } = await import('@opencode-ai/sdk/v2');
     const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
     const result = await Promise.race([
         client.session.list(),
@@ -255,7 +305,7 @@ export async function initOpenCode() {
             opencodeServer.on('exit', (code) => console.log(`[opencode] exited with code ${code}`));
 
             // Wait for server to be ready
-            const { createOpencodeClient } = await import('@opencode-ai/sdk');
+            const { createOpencodeClient } = await import('@opencode-ai/sdk/v2');
             for (let i = 0; i < 15; i++) {
                 await new Promise(r => setTimeout(r, 1000));
                 try {
@@ -318,7 +368,7 @@ export async function createSession(_threadId, title = `Remote control session`)
     const opencode = await initOpenCode();
     try {
         const createResult = await opencode.client.session.create({
-            body: { title },
+            title,
         });
         if (createResult.error) {
             console.error('Failed to create session:', createResult.error);
@@ -329,7 +379,7 @@ export async function createSession(_threadId, title = `Remote control session`)
         let shareUrl;
         if (process.env.SHARE_SESSIONS === 'true') {
             const shareResult = await opencode.client.session.share({
-                path: { id: sessionId }
+                sessionID: sessionId,
             });
             if (!shareResult.error && shareResult.data?.share?.url) {
                 shareUrl = shareResult.data.share.url;
@@ -349,14 +399,13 @@ export async function createSession(_threadId, title = `Remote control session`)
     }
 }
 // Send message - use promptAsync then poll for response
-export async function sendMessage(session, message, callbacks) {
-    const TIMEOUT_MS = 5 * 60 * 1000; // 5 minute timeout
-    const POLL_INTERVAL = 2000; // 2 seconds between polls
-    
+export async function sendMessage(session, message, callbacks, threadId) {
+    const TIMEOUT_MS = 5 * 60 * 1000;
+
     try {
         // Verify session is valid first
         try {
-            const sessionCheck = await session.client.session.get({ path: { id: session.sessionId } });
+            const sessionCheck = await session.client.session.get({ sessionID: session.sessionId });
             if (sessionCheck.error) {
                 console.error('[sendMessage] Session error:', sessionCheck.error);
                 return '❌ 会话无效，请发送 /restart 重启';
@@ -365,22 +414,16 @@ export async function sendMessage(session, message, callbacks) {
             console.error('[sendMessage] Session check failed:', e.message);
             return '❌ 会话连接失败，请发送 /restart 重启';
         }
-        
-        // Get last message ID and count before sending
-        let lastMsgId = null;
-        let msgCountBefore = 0;
-        try {
-            const msgsBefore = await session.client.session.messages({ path: { id: session.sessionId } });
-            if (msgsBefore.data?.length > 0) {
-                lastMsgId = msgsBefore.data[msgsBefore.data.length - 1].info?.id;
-                msgCountBefore = msgsBefore.data.length;
-            }
-        } catch { /* ignore */ }
-        
-        // Send message using promptAsync (non-blocking)
+
+        // Build prompt body
         const promptBody = {
             parts: [{ type: 'text', text: message }]
         };
+        // Inject local model preference if set
+        if (threadId && threadModels.has(threadId)) {
+            session.model = threadModels.get(threadId);
+            pushRecent(session.model);
+        }
         // Per-message model override if set on session
         if (session.model?.providerID && session.model?.modelID) {
             promptBody.model = {
@@ -388,124 +431,101 @@ export async function sendMessage(session, message, callbacks) {
                 modelID: session.model.modelID,
             };
         }
-        const sendResult = await session.client.session.promptAsync({
-            path: { id: session.sessionId },
-            body: promptBody,
-        });
 
-        // Poll for new response - keep going as long as new content keeps arriving
-        const startTime = Date.now();
-        let responseText = '';
-        let hasToolActivity = false;
-        let idleSince = 0; // 最后一次收到新内容的时间戳
-        let lastStatus = '';
+        // Stream the response via session.prompt (POST /session/{sessionID}/message)
+        const abortController = new AbortController();
+        const timeoutId = setTimeout(() => abortController.abort(), TIMEOUT_MS);
 
-        while (Date.now() - startTime < TIMEOUT_MS) {
-            await new Promise(r => setTimeout(r, POLL_INTERVAL));
+        try {
+            const response = await session.client.session.prompt({
+                sessionID: session.sessionId,
+                parts: promptBody.parts,
+                ...(promptBody.model ? { model: promptBody.model } : {}),
+            }, {
+                parseAs: 'stream',
+                signal: abortController.signal,
+            });
 
-            try {
-                const msgsResult = await session.client.session.messages({
-                    path: { id: session.sessionId }
-                });
+            if (response.error) {
+                return `❌ 发送失败: ${response.error}`;
+            }
 
-                if (msgsResult.error) { console.error('[sendMessage] Messages error:', msgsResult.error); break; }
-                if (!msgsResult.data?.length) continue;
+            const stream = response.data;
+            if (!stream) {
+                return '❌ 未收到响应流';
+            }
 
-                const messages = msgsResult.data;
+            const reader = stream.getReader();
+            const decoder = new TextDecoder();
+            let rawJson = '';
+            let responseText = '';
 
-                // 工具活动
-                for (let i = msgCountBefore; i < messages.length; i++) {
-                    const msg = messages[i];
-                    if (msg.parts) for (const part of msg.parts) {
-                        if (part.type === 'tool_use' || part.type === 'tool_result') {
-                            hasToolActivity = true;
-                            callbacks?.onEvent?.({ type: 'tool.call', properties: { name: part.name || part.tool_name || 'unknown', input: part.input || {} } });
-                            break;
-                        }
-                    }
-                    if (hasToolActivity) break;
-                }
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const chunk = decoder.decode(value, { stream: true });
+                if (!chunk) continue;
+                rawJson += chunk;
+            }
 
-                // 收集所有新的 assistant 回复（累加，不丢内容）
-                if (lastMsgId) {
-                    const idx = messages.findIndex(m => m.info?.id === lastMsgId);
-                    const startIdx = idx >= 0 ? idx + 1 : 0;
-                    const newParts = [];
-                    for (let i = startIdx; i < messages.length; i++) {
-                        const msg = messages[i];
-                        if (msg.info?.role === 'assistant' && msg.parts) {
-                            for (const p of msg.parts) {
-                                if (p.type === 'text' && p.text) newParts.push(p.text);
+            // Parse the full response JSON
+            if (isRawDebug()) console.log('[RAW]', rawJson);
+            try {
+                const parsed = JSON.parse(rawJson);
+                const t = parsed.info?.tokens || {};
+                const time = parsed.info?.time || {};
+                const elapsed = time.completed && time.created ? `${(time.completed - time.created) / 1000}s` : '?';
+                const cacheRead = t.cache?.read || 0;
+                const cacheWrite = t.cache?.write || 0;
+                const cacheRate = cacheRead + cacheWrite > 0 ? `${(cacheRead / (cacheRead + cacheWrite) * 100).toFixed(0)}%` : '-';
+                console.log(`[RESPONSE] ${parsed.info?.providerID}/${parsed.info?.modelID} │ ${elapsed} │ tokens=${t.total || '?'} (in=${t.input} out=${t.output} rsn=${t.reasoning}) │ cache ${cacheRate} │ finish=${parsed.info?.finish || '?'}`);
+                const meta = { modelID: parsed.info?.modelID, providerID: parsed.info?.providerID, tokens: t, parts: parsed.parts };
+                callbacks?.onResponseMeta?.(meta);
+                if (parsed.parts) {
+                    for (const part of parsed.parts) {
+                        if (part.type === 'text' && part.text) {
+                            responseText += part.text;
+                            callbacks?.onNewContent?.(part.text);
+                            callbacks?.onTextDelta?.(part.text);
+                        }
+                        if (part.type === 'reasoning' && part.text) {
+                            const cleaned = part.text.replace(/\n/g, ' ').trim();
+                            console.log(`[REASONING] ${cleaned.slice(0, 300)}`);
+                            if (thinkVisibleEnabled) {
+                                responseText += `\n🤔 思考: ${cleaned}\n━━━━━━━━━━━━━━━━━━\n`;
+                                callbacks?.onNewContent?.(`\n🤔 思考: ${cleaned}\n━━━━━━━━━━━━━━━━━━\n`);
                             }
                         }
                     }
-                    const fullText = newParts.join('\n');
-                    if (fullText && fullText !== responseText) {
-                        const delta = fullText.slice(responseText.length);
-                        responseText = fullText;
-                        callbacks?.onTextDelta?.(delta);
-                        callbacks?.onNewContent?.(delta);
-                        idleSince = Date.now();
-                        continue;
-                    }
                 }
-
-                // 检查 AI 是否还在忙（thinking/pending_tool 说明还没干完）
-                const latestStatus = msgsResult.data?.length ? msgsResult.data[msgsResult.data.length - 1]?.info?.status : '';
-                if (latestStatus === 'thinking' || latestStatus === 'pending_tool') {
-                    idleSince = Date.now();
-                }
-                if (latestStatus) lastStatus = latestStatus;
-                if (latestStatus && latestStatus !== lastReportedStatus) {
-                    lastReportedStatus = latestStatus;
-                    console.log(`[AI状态] ${latestStatus}`);
-                }
-
-                // 有回复后：等 30 秒无新内容且 AI 不忙才退出
-                if (responseText && Date.now() - idleSince > 30000) {
-                    break;
+                if (!responseText && parsed.info?.finish) {
+                    responseText = '[empty response]';
                 }
             } catch (e) {
-                console.warn('Poll error:', e.message);
+                console.error('[sendMessage] Failed to parse response:', e.message);
+                console.log('[RAW]', rawJson.slice(0, 1000));
+                responseText = rawJson;
             }
+
+            callbacks?.onStatusChange?.({ type: 'idle' });
+            return responseText;
+
+        } finally {
+            clearTimeout(timeoutId);
         }
-        
-        if (!responseText) {
-            console.warn('⏰ Timeout waiting for response, status:', lastStatus);
-            // Try one more time with a fresh message query
-            try {
-                const finalMsgs = await session.client.session.messages({ path: { id: session.sessionId }, query: { limit: 50 } });
-                if (finalMsgs.data?.length) {
-                    for (let i = finalMsgs.data.length - 1; i >= 0; i--) {
-                        const msg = finalMsgs.data[i];
-                        if (msg.info?.role === 'assistant' && msg.parts) {
-                            const textParts = msg.parts.filter(p => p.type === 'text' && p.text).map(p => p.text);
-                            if (textParts.length > 0) {
-                                responseText = textParts.join('\n');
-                                break;
-                            }
-                        }
-                    }
-                }
-            } catch { /* ignore */ }
-            
-            if (!responseText) {
-                return '⏰ 请求超时，请重试';
-            }
+    } catch (error) {
+        if (error.name === 'AbortError') {
+            console.warn('[sendMessage] 5min timeout, aborting stream');
+            return '⏰ 请求超时，请重试';
         }
-        
-        callbacks?.onStatusChange?.({ type: 'idle', hasToolActivity });
-        return responseText;
-    }
-    catch (error) {
-        console.error('Error sending message:', error);
+        console.error('[sendMessage] Error:', error);
         return `❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}`;
     }
 }
 export async function getSession(session) {
     try {
         const result = await session.client.session.get({
-            path: { id: session.sessionId }
+            sessionID: session.sessionId
         });
         if (result.error) {
             return null;
@@ -519,7 +539,7 @@ export async function getSession(session) {
 export async function shareSession(session) {
     try {
         const result = await session.client.session.share({
-            path: { id: session.sessionId }
+            sessionID: session.sessionId
         });
         if (result.error || !result.data?.share?.url) {
             return null;
@@ -545,7 +565,7 @@ export async function checkConnection() {
 export async function abortSession(session) {
     try {
         await session.client.session.abort({
-            path: { id: session.sessionId }
+            sessionID: session.sessionId
         });
         console.log(`🛑 Aborted session: ${session.sessionId}`);
         return true;
@@ -558,7 +578,7 @@ export async function abortSession(session) {
 export async function getSessionMessages(session, limit = 20) {
     try {
         const result = await session.client.session.messages({
-            path: { id: session.sessionId }
+            sessionID: session.sessionId
         });
         if (result.error) {
             return null;
@@ -574,7 +594,7 @@ export async function resumeSession(sessionId, title = 'Resumed session') {
     try {
         const opencode = await initOpenCode();
         if (!opencode) return null;
-        const getResult = await opencode.client.session.get({ path: { id: sessionId } });
+        const getResult = await opencode.client.session.get({ sessionID: sessionId });
         if (getResult.error) {
             console.warn(`Session ${sessionId} not found`);
             return null;
@@ -599,10 +619,9 @@ export async function listOpenCodeSessions() {
         return sessions.map(s => ({
             id: s.id,
             title: s.title || 'Untitled',
-            status: s.status?.type || 'unknown',
             directory: s.directory || '',
-            createdAt: s.created_at || 0,
-            lastActivity: s.updated_at || 0,
+            createdAt: s.created_at || s.time?.created || 0,
+            lastActivity: s.updated_at || s.time?.updated || 0,
         }));
     }
     catch (error) {
@@ -612,7 +631,7 @@ export async function listOpenCodeSessions() {
 }
 export async function listOpenCodeSessionsFromServer(baseUrl) {
     try {
-        const { createOpencodeClient } = await import('@opencode-ai/sdk');
+        const { createOpencodeClient } = await import('@opencode-ai/sdk/v2');
         const client = createOpencodeClient({
             baseUrl: baseUrl || 'http://localhost:4096',
         });
@@ -624,10 +643,9 @@ export async function listOpenCodeSessionsFromServer(baseUrl) {
         return sessions.map(s => ({
             id: s.id,
             title: s.title || 'Untitled',
-            status: s.status?.type || 'unknown',
             directory: s.directory || '',
-            createdAt: s.created_at || 0,
-            lastActivity: s.updated_at || 0,
+            createdAt: s.created_at || s.time?.created || 0,
+            lastActivity: s.updated_at || s.time?.updated || 0,
         }));
     }
     catch (error) {
@@ -640,7 +658,7 @@ export async function createOpenCodeSession(title = 'New session') {
         const opencode = await initOpenCode();
         if (!opencode) return null;
         const result = await opencode.client.session.create({
-            body: { title }
+            title
         });
         if (result.error) {
             return null;
@@ -664,7 +682,7 @@ export async function deleteOpenCodeSession(sessionId) {
         const opencode = await initOpenCode();
         if (!opencode) return false;
         const result = await opencode.client.session.delete({
-            path: { id: sessionId }
+            sessionID: sessionId
         });
         if (result.error) {
             return false;
@@ -679,9 +697,9 @@ export async function deleteOpenCodeSession(sessionId) {
 }
 export async function renameOpenCodeSession(session, title) {
     try {
-        const result = await session.client.session.patch({
-            path: { id: session.sessionId },
-            body: { title }
+        const result = await session.client.session.update({
+            sessionID: session.sessionId,
+            title,
         });
         if (result.error) {
             return false;
@@ -699,9 +717,9 @@ export async function forkSession(sessionId, messageID, directory) {
         const opencode = await initOpenCode();
         if (!opencode) return null;
         const result = await opencode.client.session.fork({
-            path: { id: sessionId },
-            body: { messageID },
-            query: directory ? { directory } : {}
+            sessionID: sessionId,
+            messageID,
+            ...(directory ? { directory } : {}),
         });
         if (result.error) {
             console.warn(`Fork failed: ${result.error}`);
@@ -726,8 +744,9 @@ export async function revertSessionMessage(sessionId, messageID, partID) {
         const opencode = await initOpenCode();
         if (!opencode) return false;
         const result = await opencode.client.session.revert({
-            path: { id: sessionId },
-            body: { messageID, partID }
+            sessionID: sessionId,
+            messageID,
+            partID,
         });
         if (result.error) {
             console.warn(`Revert failed: ${result.error}`);
@@ -746,7 +765,7 @@ export async function unrevertSession(sessionId) {
         const opencode = await initOpenCode();
         if (!opencode) return false;
         const result = await opencode.client.session.unrevert({
-            path: { id: sessionId }
+            sessionID: sessionId
         });
         if (result.error) {
             console.warn(`Unrevert failed: ${result.error}`);
@@ -765,9 +784,12 @@ export async function listProviders() {
     try {
         const opencode = await initOpenCode();
         if (!opencode) return null;
-        const result = await opencode.client.provider.list();
-        if (result.error || !result.data?.all) return null;
-        return result.data.all;
+        // Config2.providers() → GET /config/providers (same as v1)
+        const result = await opencode.client.config.providers();
+        if (result.error) return null;
+        // v2 returns { providers: [...] }, v1 returns { all: [...] }
+        const data = result.data?.providers || result.data?.all || result.data || [];
+        return Array.isArray(data) ? data : null;
     } catch (error) {
         console.error('Failed to list providers:', error.message);
         return null;
@@ -779,7 +801,7 @@ export async function updateGlobalModel(modelStr) {
         const opencode = await initOpenCode();
         if (!opencode) return false;
         const result = await opencode.client.config.update({
-            body: { model: modelStr },
+            config: { model: modelStr },
         });
         if (result.error) {
             console.error('Failed to update model:', result.error);

package/dist/plugins/agents/claude-code/index.js

@@ -24,9 +24,13 @@ export class ClaudeCodeAgentAdapter {
 
     async sendPrompt(_sessionId, prompt, history, options = {}) {
         const projectDir = options.projectDir;
-        const contextualPrompt = this.buildContextualPrompt(prompt, history);
+        let cleanPrompt = prompt;
+        if (prompt.startsWith('-c')) {
+            cleanPrompt = prompt.slice(2).trim();
+        }
+        const contextualPrompt = this.buildContextualPrompt(cleanPrompt, history);
 
-        const args = ['--print', contextualPrompt];
+        const args = ['--print', '-c', contextualPrompt];
 
         return this.callClaude(args, projectDir);
     }

package/dist/plugins/agents/opencode/index.js

@@ -22,11 +22,15 @@ export class OpenCodeAgentAdapter {
         });
     }
     
-    async sendPrompt(_sessionId, prompt, history) {
-        const contextualPrompt = this.buildContextualPrompt(prompt, history);
+    async sendPrompt(_sessionId, prompt, history, options = {}) {
+        let cleanPrompt = prompt;
+        if (prompt.startsWith('-c')) {
+            cleanPrompt = prompt.slice(2).trim();
+        }
+        const contextualPrompt = this.buildContextualPrompt(cleanPrompt, history);
         return this.callOpenCode(contextualPrompt);
     }
-    
+
     buildContextualPrompt(prompt, history) {
         if (!history || history.length === 0) return prompt;
         const historyText = history
@@ -34,7 +38,7 @@ export class OpenCodeAgentAdapter {
             .join('\n\n');
         return `Previous conversation:\n${historyText}\n\nCurrent request: ${prompt}`;
     }
-    
+
     extractErrorMessage(stdout, stderr) {
         const lines = [...stdout.trim().split('\n'), ...stderr.trim().split('\n')]
             .map(l => l.trim()).filter(Boolean)
@@ -48,7 +52,7 @@ export class OpenCodeAgentAdapter {
 
     callOpenCode(prompt) {
         return new Promise((resolve) => {
-            const proc = spawn('opencode', ['run', '--format', 'json', prompt], {
+            const proc = spawn('opencode', ['run', '--format', 'json', '-c', prompt], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             });
@@ -56,11 +60,33 @@ export class OpenCodeAgentAdapter {
             let stdout = '';
             let stderr = '';
             let fullText = '';
+            let resigned = false;
+
+            const STUCK_PATTERNS = [
+                'Free usage exceeded', 'quota exceeded', 'rate limit',
+                'retrying in', 'retry attempt',
+                '429', '401', '403', '402', 'Payment Required',
+                'subscription required', 'insufficient_quota',
+            ];
+
+            const checkStuck = (stderrText) => {
+                if (resigned) return;
+                for (const pattern of STUCK_PATTERNS) {
+                    if (stderrText.toLowerCase().includes(pattern.toLowerCase())) {
+                        resigned = true;
+                        proc.kill();
+                        const detail = this.extractErrorMessage('', stderrText);
+                        resolve(`❌ OpenCode 无法继续: ${detail || pattern}`);
+                        return true;
+                    }
+                }
+                return false;
+            };
 
             proc.stdout?.on('data', (data) => {
-                stdout += data.toString();
-                const lines = stdout.split('\n');
-                stdout = lines.pop() || '';
+                const chunk = data.toString();
+                stdout += chunk;
+                const lines = chunk.split('\n');
                 for (const line of lines) {
                     if (!line.trim()) continue;
                     try {
@@ -70,15 +96,19 @@ export class OpenCodeAgentAdapter {
                 }
             });
 
-            proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+                checkStuck(stderr);
+            });
 
             proc.on('close', (code) => {
+                if (resigned) return;
                 if (code !== 0) {
                     const detail = this.extractErrorMessage(stdout, stderr);
                     const hint = detail
                         ? `: ${detail}`
                         : '。请运行 `opencode auth login` 配置认证。';
-                    resolve(`❌ OpenCode 错误${hint}`);
+                    resolve(`❌ OpenCode 错误 (exit code ${code})${hint}`);
                 } else {
                     resolve(fullText || '完成');
                 }

package/dist/telegram/adapter.js

@@ -38,12 +38,9 @@ export class TelegramAdapter {
     async sendCommandMenu(threadId, title) {
         if (!this.bot) return;
         const groups = [
-            ['🟢 常用', ['/help', '/status', '/start', '/reset']],
-            ['🔄 任务', ['/loop', '/refresh', '/restart']],
-            ['🤖 AI', ['/model', '/agents', '/oc', '/cc']],
-            ['🧠 专家', ['/tutorial', '/z', '/diagnose']],
-            ['📂 会话', ['/sessions', '/delsessions', '/copy', '/revert']],
-            ['⬆️ 文件', ['/upload', '/delete']],
+            ['/help', '/start', '/reset', '/diagnose'],
+            ['/restart', '/model', '/oc', '/cc'],
+            ['/cx', '/copilot'],
         ];
         const keyboard = [];
         for (const [, cmds] of groups) {

package/dist/telegram/bot.js

@@ -1,8 +1,8 @@
 import { registry } from '../core/registry.js';
-import { sessionManager } from '../core/session.js';
 import { initOpenCode, createSession, sendMessage as sendToOpenCode, checkConnection } from '../opencode/client.js';
 import { parseMessage, routeMessage } from '../core/router.js';
 import { telegramAdapter } from './adapter.js';
+import { splitMessage } from '../utils/message-split.js';
 
 export async function startBot() {
     const { loadConfig } = await import('../core/config.js');
@@ -17,7 +17,6 @@ export async function startBot() {
         process.exit(1);
     }
 
-    await sessionManager.start();
     await registry.loadBuiltInPlugins();
     await telegramAdapter.start(config);
 
@@ -68,10 +67,6 @@ export async function startBot() {
             if (parsed.type === 'command' && parsed.command === 'reset') {
                 openCodeSessions.delete(message.threadId);
                 opencodeSessionId = null;
-                try {
-                    const session = await sessionManager.getExistingSession(platform, channelId, message.threadId);
-                    if (session) await sessionManager.resetConversation(platform, channelId, message.threadId);
-                } catch (e) { console.warn('[Telegram] Reset error:', e.message); }
             }
 
             if (parsed.type === 'default') {