hakimi 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# Hakimi
+
+Hakimi lets you chat with an AI assistant via Telegram/Slack/Feishu to remotely control your computer.
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install
+```
+
+### 2. Run
+
+```bash
+npm run dev
+```
+
+Debug mode (show detailed logs):
+
+```bash
+npm run dev -- --debug
+```
+
+### 3. Login to Kimi Code
+
+Press `L` to login to your Kimi Code account. Follow the prompts to complete authorization in your browser.
+
+### 4. Configure
+
+Press `C` to start the configuration wizard. The AI assistant will guide you through:
+- Naming your AI assistant
+- Setting up chat platforms (Telegram/Slack/Feishu)
+
+### 5. Start Using
+
+Press `S` to start the service, then send messages to your Bot on the chat platform.
+
+## Supported Platforms
+
+### Telegram
+
+1. Search for @BotFather on Telegram
+2. Send `/newbot` to create a bot
+3. Get the Bot Token
+
+### Slack
+
+1. Go to https://api.slack.com/apps to create an app
+2. Get the App-Level Token (`xapp-...`)
+3. Get the Bot User OAuth Token (`xoxb-...`)
+
+### Feishu (Lark)
+
+1. Go to https://open.feishu.cn to create an app
+2. Get the App ID and App Secret
+
+## Config File Locations
+
+- Kimi Code: `~/.kimi/config.toml`
+- Hakimi: `~/.hakimi/config.toml`
+
+## Hotkeys
+
+| Key | Function |
+|-----|----------|
+| L | Login to Kimi Code |
+| C | Configuration wizard |
+| S | Start/Stop service |
+| Q | Quit |
+| Esc | Back/Cancel |

package/dist/App.d.ts

@@ -0,0 +1,5 @@
+interface AppProps {
+    debug?: boolean;
+}
+export declare function App({ debug }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/App.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { HomeScreen } from './screens/HomeScreen.js';
+import { LoginScreen } from './screens/LoginScreen.js';
+import { ConfigScreen } from './screens/ConfigScreen.js';
+import { isLoggedIn as checkLoggedIn, readHakimiConfig } from './utils/config.js';
+import { ChatRouter } from './services/chatRouter.js';
+export function App({ debug = false }) {
+    const { exit } = useApp();
+    const [screen, setScreen] = useState('home');
+    const [loggedIn, setLoggedIn] = useState(false);
+    const [adaptersConfigured, setAdaptersConfigured] = useState(0);
+    const [chatActive, setChatActive] = useState(false);
+    const [logs, setLogs] = useState([]);
+    const [lastMessage, setLastMessage] = useState(null);
+    const logsRef = useRef(logs);
+    logsRef.current = logs;
+    const addLog = useCallback((message) => {
+        const timestamp = new Date().toLocaleTimeString();
+        setLogs((prev) => [...prev.slice(-9), `[${timestamp}] ${message}`]);
+    }, []);
+    const [chatRouter] = useState(() => new ChatRouter({
+        onMessage: (sessionId, content) => {
+            setLastMessage({ sessionId, content });
+            if (debug)
+                addLog(`Message [${sessionId}]: ${content}`);
+        },
+        onSessionStart: (session) => {
+            addLog(`Session started: ${session.sessionId}`);
+        },
+        onSessionEnd: (sessionId) => {
+            addLog(`Session ended: ${sessionId}`);
+        },
+        onLog: (message) => {
+            if (debug)
+                addLog(message);
+        },
+    }));
+    const refreshStatus = useCallback(async () => {
+        const isLogged = await checkLoggedIn();
+        setLoggedIn(isLogged);
+        const config = await readHakimiConfig();
+        setAdaptersConfigured(config?.adapters?.length ?? 0);
+    }, []);
+    useEffect(() => {
+        refreshStatus();
+    }, [refreshStatus]);
+    const handleLoginSuccess = useCallback(() => {
+        setLoggedIn(true);
+        setScreen('home');
+        refreshStatus();
+    }, [refreshStatus]);
+    const handleConfigFinished = useCallback(() => {
+        setScreen('home');
+        refreshStatus();
+    }, [refreshStatus]);
+    const handleToggleChat = useCallback(async () => {
+        if (chatActive) {
+            await chatRouter.stop();
+            setChatActive(false);
+        }
+        else {
+            try {
+                await chatRouter.start();
+                setChatActive(true);
+            }
+            catch (error) {
+                console.error('Failed to start chat:', error);
+            }
+        }
+    }, [chatActive, chatRouter]);
+    const handleQuit = useCallback(async () => {
+        if (chatRouter.running) {
+            await chatRouter.stop();
+        }
+        exit();
+    }, [chatRouter, exit]);
+    return (_jsxs(Box, { flexDirection: "column", children: [screen === 'home' && (_jsx(HomeScreen, { isLoggedIn: loggedIn, adaptersConfigured: adaptersConfigured, chatActive: chatActive, onLogin: () => setScreen('login'), onConfig: () => setScreen('config'), onChat: handleToggleChat, onQuit: handleQuit, isActive: screen === 'home' })), screen === 'login' && (_jsx(LoginScreen, { onSuccess: handleLoginSuccess, onCancel: () => setScreen('home'), isActive: screen === 'login' })), screen === 'config' && (_jsx(ConfigScreen, { onFinished: handleConfigFinished, onCancel: () => setScreen('home'), isActive: screen === 'config' })), chatActive && debug && logs.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsx(Text, { color: "gray", children: "\u2500\u2500\u2500 Debug Logs \u2500\u2500\u2500" }), logs.map((log, i) => (_jsx(Text, { color: "gray", dimColor: true, children: log }, i)))] })), chatActive && !debug && lastMessage && (_jsxs(Box, { marginTop: 1, paddingX: 1, children: [_jsx(Text, { color: "gray", children: "\u4E0A\u6B21\u6536\u5230: " }), _jsxs(Text, { color: "cyan", children: ["[", lastMessage.sessionId, "] "] }), _jsx(Text, { children: lastMessage.content.length > 50 ? lastMessage.content.slice(0, 50) + '...' : lastMessage.content })] }))] }));
+}

package/dist/components/HotkeyHint.d.ts

@@ -0,0 +1,9 @@
+interface HotkeyHintProps {
+    hints: Array<{
+        key: string;
+        label: string;
+        disabled?: boolean;
+    }>;
+}
+export declare function HotkeyHint({ hints }: HotkeyHintProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/HotkeyHint.js

@@ -0,0 +1,5 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function HotkeyHint({ hints }) {
+    return (_jsx(Box, { gap: 2, marginTop: 1, children: hints.map(({ key, label, disabled }) => (_jsxs(Box, { children: [_jsxs(Text, { color: disabled ? 'gray' : 'cyan', bold: true, children: ["[", key, "]"] }), _jsxs(Text, { color: disabled ? 'gray' : undefined, children: [" ", label] })] }, key))) }));
+}

package/dist/components/MessageLog.d.ts

@@ -0,0 +1,12 @@
+export interface Message {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: Date;
+}
+interface MessageLogProps {
+    messages: Message[];
+    maxHeight?: number;
+}
+export declare function MessageLog({ messages, maxHeight }: MessageLogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/MessageLog.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function MessageLog({ messages, maxHeight = 10 }) {
+    const visibleMessages = messages.slice(-maxHeight);
+    return (_jsx(Box, { flexDirection: "column", children: visibleMessages.length === 0 ? (_jsx(Text, { color: "gray", children: "No messages yet..." })) : (visibleMessages.map((msg) => (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: msg.role === 'user'
+                        ? 'blue'
+                        : msg.role === 'assistant'
+                            ? 'green'
+                            : 'yellow', bold: true, children: [msg.role === 'user' ? 'You' : msg.role === 'assistant' ? 'Hakimi' : 'System', ":"] }), _jsxs(Text, { children: [" ", msg.content] })] }, msg.id)))) }));
+}

package/dist/components/StatusBar.d.ts

@@ -0,0 +1,7 @@
+interface StatusBarProps {
+    isLoggedIn: boolean;
+    adaptersConfigured: number;
+    chatActive: boolean;
+}
+export declare function StatusBar({ isLoggedIn, adaptersConfigured, chatActive }: StatusBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/StatusBar.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function StatusBar({ isLoggedIn, adaptersConfigured, chatActive }) {
+    return (_jsxs(Box, { borderStyle: "single", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Hakimi Status" }), _jsxs(Box, { children: [_jsx(Text, { children: "Kimi: " }), isLoggedIn ? (_jsx(Text, { color: "green", children: "Logged in" })) : (_jsx(Text, { color: "yellow", children: "Not logged in" }))] }), _jsxs(Box, { children: [_jsx(Text, { children: "Adapters: " }), adaptersConfigured > 0 ? (_jsxs(Text, { color: "green", children: [adaptersConfigured, " configured"] })) : (_jsx(Text, { color: "yellow", children: "None configured" }))] }), _jsxs(Box, { children: [_jsx(Text, { children: "Chat: " }), chatActive ? (_jsx(Text, { color: "green", children: "Active" })) : (_jsx(Text, { color: "gray", children: "Inactive" }))] })] }));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './App.js';
+const debug = process.argv.includes('--debug');
+// Global error handlers to prevent crash
+process.on('uncaughtException', (error) => {
+    if (debug) {
+        console.error('[Uncaught Exception]', error);
+    }
+    // Don't exit - let the app continue
+});
+process.on('unhandledRejection', (reason) => {
+    if (debug) {
+        console.error('[Unhandled Rejection]', reason);
+    }
+    // Don't exit - let the app continue
+});
+render(_jsx(App, { debug: debug }));

package/dist/screens/ConfigScreen.d.ts

@@ -0,0 +1,7 @@
+interface ConfigScreenProps {
+    onFinished: () => void;
+    onCancel: () => void;
+    isActive: boolean;
+}
+export declare function ConfigScreen({ onFinished, onCancel, isActive }: ConfigScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/screens/ConfigScreen.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import Spinner from 'ink-spinner';
+import { MessageLog } from '../components/MessageLog.js';
+import { ConfigAgent } from '../services/configAgent.js';
+export function ConfigScreen({ onFinished, onCancel, isActive }) {
+    const [messages, setMessages] = useState([]);
+    const [inputValue, setInputValue] = useState('');
+    const [inputMode, setInputMode] = useState('chat');
+    const [pendingQuestion, setPendingQuestion] = useState(null);
+    const [isProcessing, setIsProcessing] = useState(true);
+    const [isFinished, setIsFinished] = useState(false);
+    const [error, setError] = useState(null);
+    const agentRef = useRef(null);
+    const currentResponseRef = useRef('');
+    const addMessage = useCallback((role, content) => {
+        setMessages((prev) => [
+            ...prev,
+            {
+                id: `msg-${Date.now()}-${Math.random()}`,
+                role,
+                content,
+                timestamp: new Date(),
+            },
+        ]);
+    }, []);
+    const flushCurrentResponse = useCallback(() => {
+        if (currentResponseRef.current.trim()) {
+            addMessage('assistant', currentResponseRef.current.trim());
+            currentResponseRef.current = '';
+        }
+    }, [addMessage]);
+    useEffect(() => {
+        const agent = new ConfigAgent({
+            onText: (text) => {
+                currentResponseRef.current += text;
+            },
+            onAskUser: async (question) => {
+                flushCurrentResponse();
+                return new Promise((resolve) => {
+                    setPendingQuestion({ question, resolve });
+                    setInputMode('ask_user');
+                    setInputValue('');
+                    addMessage('assistant', question);
+                    setIsProcessing(false);
+                });
+            },
+            onFinished: () => {
+                flushCurrentResponse();
+                setIsFinished(true);
+                addMessage('system', 'Configuration saved successfully!');
+                setIsProcessing(false);
+            },
+            onError: (err) => {
+                flushCurrentResponse();
+                setError(err.message);
+                setIsProcessing(false);
+            },
+        });
+        agentRef.current = agent;
+        agent.start().then(() => {
+            flushCurrentResponse();
+            setIsProcessing(false);
+        }).catch((err) => {
+            setError(err.message);
+            setIsProcessing(false);
+        });
+        return () => {
+            agent.close();
+        };
+    }, [addMessage, flushCurrentResponse]);
+    const handleSubmit = useCallback(async (value) => {
+        if (!value.trim())
+            return;
+        const agent = agentRef.current;
+        if (!agent)
+            return;
+        if (inputMode === 'ask_user' && pendingQuestion) {
+            addMessage('user', value);
+            pendingQuestion.resolve(value);
+            setPendingQuestion(null);
+            setInputMode('chat');
+            setIsProcessing(true);
+        }
+        else {
+            addMessage('user', value);
+            setIsProcessing(true);
+            flushCurrentResponse();
+            try {
+                await agent.sendMessage(value);
+                flushCurrentResponse();
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : String(err));
+            }
+            setIsProcessing(false);
+        }
+        setInputValue('');
+    }, [inputMode, pendingQuestion, addMessage, flushCurrentResponse]);
+    useInput((input, key) => {
+        if (key.escape) {
+            agentRef.current?.close();
+            if (isFinished) {
+                onFinished();
+            }
+            else {
+                onCancel();
+            }
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Adapter Configuration" }), isFinished && _jsx(Text, { color: "green", children: " (Complete)" })] }), error && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), _jsx(MessageLog, { messages: messages, maxHeight: 15 }), _jsx(Box, { marginTop: 1, children: isProcessing ? (_jsxs(Box, { children: [_jsx(Spinner, { type: "dots" }), _jsx(Text, { color: "gray", children: " Thinking..." })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: inputMode === 'ask_user' ? 'yellow' : 'blue', children: inputMode === 'ask_user' ? '? ' : '> ' }), _jsx(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit })] })) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "gray", children: ["[Esc] ", isFinished ? 'Done' : 'Cancel'] }) })] }));
+}

package/dist/screens/HomeScreen.d.ts

@@ -0,0 +1,12 @@
+interface HomeScreenProps {
+    isLoggedIn: boolean;
+    adaptersConfigured: number;
+    chatActive: boolean;
+    onLogin: () => void;
+    onConfig: () => void;
+    onChat: () => void;
+    onQuit: () => void;
+    isActive: boolean;
+}
+export declare function HomeScreen({ isLoggedIn, adaptersConfigured, chatActive, onLogin, onConfig, onChat, onQuit, isActive, }: HomeScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/screens/HomeScreen.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { StatusBar } from '../components/StatusBar.js';
+import { HotkeyHint } from '../components/HotkeyHint.js';
+export function HomeScreen({ isLoggedIn, adaptersConfigured, chatActive, onLogin, onConfig, onChat, onQuit, isActive, }) {
+    useInput((input) => {
+        if (input === 'l' || input === 'L') {
+            onLogin();
+        }
+        else if ((input === 'c' || input === 'C') && isLoggedIn) {
+            onConfig();
+        }
+        else if ((input === 's' || input === 'S') && isLoggedIn && adaptersConfigured > 0) {
+            onChat();
+        }
+        else if (input === 'q' || input === 'Q') {
+            onQuit();
+        }
+    }, { isActive });
+    const hints = [
+        { key: 'L', label: 'Login', disabled: isLoggedIn },
+        { key: 'C', label: 'Configure', disabled: !isLoggedIn },
+        { key: 'S', label: chatActive ? 'Stop Chat' : 'Start Chat', disabled: !isLoggedIn || adaptersConfigured === 0 },
+        { key: 'Q', label: 'Quit' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "magenta", children: "Hakimi - Kimi Chat Router" }) }), _jsx(StatusBar, { isLoggedIn: isLoggedIn, adaptersConfigured: adaptersConfigured, chatActive: chatActive }), _jsx(HotkeyHint, { hints: hints }), !isLoggedIn && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: "Press L to login to Kimi first" }) })), isLoggedIn && adaptersConfigured === 0 && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: "Press C to configure chat adapters" }) }))] }));
+}

package/dist/screens/LoginScreen.d.ts

@@ -0,0 +1,7 @@
+interface LoginScreenProps {
+    onSuccess: () => void;
+    onCancel: () => void;
+    isActive: boolean;
+}
+export declare function LoginScreen({ onSuccess, onCancel, isActive }: LoginScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/screens/LoginScreen.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { startLogin } from '../services/loginService.js';
+export function LoginScreen({ onSuccess, onCancel, isActive }) {
+    const [state, setState] = useState('starting');
+    const [verificationUrl, setVerificationUrl] = useState('');
+    const [userCode, setUserCode] = useState('');
+    const [message, setMessage] = useState('Starting login...');
+    const [error, setError] = useState('');
+    useInput((input, key) => {
+        if (key.escape || input === 'q' || input === 'Q') {
+            onCancel();
+        }
+        if (state === 'success' && (key.return || input === ' ')) {
+            onSuccess();
+        }
+    }, { isActive });
+    useEffect(() => {
+        const emitter = startLogin();
+        emitter.on('event', (event) => {
+            switch (event.type) {
+                case 'verification_url':
+                    setState('awaiting_auth');
+                    setVerificationUrl(event.data?.verification_url || '');
+                    setUserCode(event.data?.user_code || '');
+                    setMessage('Please authorize in your browser');
+                    break;
+                case 'waiting':
+                    setMessage(event.message);
+                    break;
+                case 'success':
+                    setState('success');
+                    setMessage(event.message);
+                    break;
+                case 'error':
+                    setState('error');
+                    setError(event.message);
+                    break;
+                case 'info':
+                    setMessage(event.message);
+                    break;
+            }
+        });
+        emitter.on('error', (err) => {
+            setState('error');
+            setError(err.message);
+        });
+        return () => {
+            emitter.removeAllListeners();
+        };
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Kimi Login" }) }), state === 'starting' && (_jsxs(Box, { children: [_jsx(Spinner, { type: "dots" }), _jsxs(Text, { children: [" ", message] })] })), state === 'awaiting_auth' && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", padding: 1, children: [_jsx(Text, { children: "Open this URL in your browser:" }), _jsx(Box, { marginY: 1, children: _jsx(Text, { bold: true, color: "blue", children: verificationUrl }) }), _jsx(Text, { children: "Enter this code:" }), _jsx(Box, { marginY: 1, children: _jsxs(Text, { bold: true, color: "green", inverse: true, children: [' ', userCode, ' '] }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Spinner, { type: "dots" }), _jsxs(Text, { color: "gray", children: [" ", message] })] })] })), state === 'success' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", children: message }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press Enter to continue..." }) })] })), state === 'error' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["Error: ", error] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press Esc to go back" }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "[Esc] Cancel" }) })] }));
+}

package/dist/services/chatAgent.d.ts

@@ -0,0 +1,18 @@
+export interface ChatAgentCallbacks {
+    onSend: (message: string) => Promise<void>;
+    onLog?: (message: string) => void;
+}
+export declare class ChatAgent {
+    private session;
+    private currentTurn;
+    private callbacks;
+    private sessionId;
+    private didSendMessage;
+    constructor(sessionId: string, callbacks: ChatAgentCallbacks);
+    private log;
+    start(): Promise<void>;
+    sendMessage(content: string): Promise<void>;
+    private runPrompt;
+    interrupt(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/services/chatAgent.js

@@ -0,0 +1,110 @@
+import { createSession, createExternalTool } from '@moonshot-ai/kimi-agent-sdk';
+import { z } from 'zod';
+import { KIMCHI_DIR } from '../utils/paths.js';
+const CHAT_SYSTEM_PROMPT = `You are a helpful assistant chatting with a user via a messaging platform.
+
+IMPORTANT: You MUST use the SendMessage tool to reply to the user. Do NOT put your reply in the assistant message content - it will be ignored. Only messages sent via SendMessage will reach the user.
+
+You can call SendMessage multiple times if needed (e.g., for long responses or multiple parts).`;
+export class ChatAgent {
+    session = null;
+    currentTurn = null;
+    callbacks;
+    sessionId;
+    didSendMessage = false;
+    constructor(sessionId, callbacks) {
+        this.sessionId = sessionId;
+        this.callbacks = callbacks;
+    }
+    log(message) {
+        this.callbacks.onLog?.(message);
+    }
+    async start() {
+        const sendMessageTool = createExternalTool({
+            name: 'SendMessage',
+            description: 'Send a message to the user. You MUST use this tool to reply. Your assistant message content will NOT be shown to the user.',
+            parameters: z.object({
+                message: z.string().describe('The message to send to the user'),
+            }),
+            handler: async (params) => {
+                this.didSendMessage = true;
+                this.log(`Sending: ${params.message.slice(0, 50)}...`);
+                await this.callbacks.onSend(params.message);
+                return { output: 'Message sent successfully', message: '' };
+            },
+        });
+        this.session = createSession({
+            workDir: KIMCHI_DIR,
+            sessionId: `chat-${this.sessionId}`,
+            thinking: false,
+            yoloMode: true,
+            externalTools: [sendMessageTool],
+        });
+        // Initialize with system prompt
+        await this.runPrompt(CHAT_SYSTEM_PROMPT);
+    }
+    async sendMessage(content) {
+        if (!this.session) {
+            throw new Error('Session not started');
+        }
+        // Reset send flag
+        this.didSendMessage = false;
+        // Send user message
+        await this.runPrompt(`User message: ${content}`);
+        // If agent didn't use SendMessage, prompt again
+        let retries = 0;
+        while (!this.didSendMessage && retries < 3) {
+            retries++;
+            this.log(`Agent did not send message, prompting again (retry ${retries})...`);
+            await this.runPrompt('You did not send a message to the user. Please use the SendMessage tool to reply.');
+        }
+        if (!this.didSendMessage) {
+            this.log('Agent failed to send message after retries');
+            await this.callbacks.onSend('Sorry, I encountered an error processing your message.');
+        }
+    }
+    async runPrompt(content) {
+        if (!this.session)
+            return;
+        const turn = this.session.prompt(content);
+        this.currentTurn = turn;
+        try {
+            for await (const event of turn) {
+                // Handle approval requests automatically
+                if (event.type === 'ApprovalRequest' && this.currentTurn) {
+                    this.currentTurn.approve(event.payload.id, 'approve').catch(() => { });
+                }
+                // Ignore text content - only SendMessage matters
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('interrupted')) {
+                return;
+            }
+            throw error;
+        }
+        finally {
+            if (this.currentTurn === turn) {
+                this.currentTurn = null;
+            }
+        }
+    }
+    async interrupt() {
+        if (this.currentTurn) {
+            try {
+                await this.currentTurn.interrupt();
+            }
+            catch {
+                // Ignore interrupt errors
+            }
+            this.currentTurn = null;
+        }
+    }
+    async close() {
+        await this.interrupt();
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}

package/dist/services/chatRouter.d.ts

@@ -0,0 +1,39 @@
+import { TheAgent } from './theAgent.js';
+export interface ChatSession {
+    sessionId: string;
+    platform: string;
+    userId: string;
+    botId: string;
+    isProcessing: boolean;
+    sendFn: (message: string) => Promise<void>;
+    agent: TheAgent | null;
+    pendingMessage: string | null;
+}
+export interface ChatRouterOptions {
+    onMessage: (sessionId: string, content: string) => void;
+    onSessionStart: (session: ChatSession) => void;
+    onSessionEnd: (sessionId: string) => void;
+    onLog?: (message: string) => void;
+}
+export declare class ChatRouter {
+    private ctx;
+    private sessionCache;
+    private options;
+    private isRunning;
+    private agentName;
+    private retryTimeouts;
+    constructor(options: ChatRouterOptions);
+    private log;
+    private sleep;
+    private sendWithRetry;
+    start(): Promise<void>;
+    private startWithRetry;
+    private scheduleReconnect;
+    private loadAdapter;
+    private handleMessage;
+    private processMessage;
+    getSession(sessionId: string): ChatSession | undefined;
+    stop(): Promise<void>;
+    get running(): boolean;
+    get activeSessions(): number;
+}