@hailer/mcp 0.2.7 → 1.0.20

package/.claude/skills/client-bot-architecture/skill.md

@@ -0,0 +1,340 @@
+# Client Bot Architecture Reference
+
+Load this skill when working on the client bot system (bot-manager, daemon, token billing, MCP tool execution).
+
+**Full Documentation:** See `docs/client-bots/` for comprehensive guides:
+- [index.md](../../../docs/client-bots/index.md) - Overview
+- [architecture.md](../../../docs/client-bots/architecture.md) - Data flows, initialization
+- [services.md](../../../docs/client-bots/services.md) - All 11 services
+- [token-costs.md](../../../docs/client-bots/token-costs.md) - AI + Hailer costs
+- [memory-context.md](../../../docs/client-bots/memory-context.md) - 3-layer context
+- [configuration.md](../../../docs/client-bots/configuration.md) - Env vars, config files
+- [edge-cases.md](../../../docs/client-bots/edge-cases.md) - Race conditions, gotchas
+
+---
+
+## Architecture Overview
+
+The client bot system is a multi-bot orchestration platform for Hailer workspaces:
+- **HAL Orchestrator** - Main bot that monitors chats, classifies messages, coordinates specialists
+- **Specialist Bots** - Focused bots for specific tasks (invoked by HAL)
+- **Bot Manager** - Manages multiple bot connections and credentials
+- **Token Billing** - Real-time per-workspace cost tracking
+
+---
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/agents/bot-manager.ts` | Multi-bot connection pool, credential management |
+| `src/agents/hal/daemon.ts` | HAL orchestrator, message routing, specialist coordination |
+| `src/agents/shared/base.ts` | ChatAgentDaemon base class, core processing loop |
+| `src/agents/shared/services/token-billing.ts` | Per-workspace token burning |
+| `src/bot-config/context.ts` | Per-workspace singleton, Agent Directory discovery |
+| `src/mcp/hailer-clients.ts` | HailerClient pool, signal subscriptions |
+| `src/mcp/tools/activity.ts` | list_activities, create_activity, update_activity |
+| `src/mcp/tools/discussion.ts` | join_discussion, fetch_messages, add_message |
+
+---
+
+## Message Processing Flow
+
+```
+User message in workspace
+  ↓
+[Signal: messenger.new] → HailerClientManager
+  ↓
+ChatAgentDaemon.handleSignal()
+  ↓
+MessageClassifier.extractIncomingMessage()
+  → Priority: HIGH (DM, @mention, reply) or NORMAL
+  ↓
+processMessage(IncomingMessage)
+  → Check token balance (first message)
+  → Load memory from Session Log (cold start)
+  → Build per-discussion conversation
+  ↓
+Call LLM with conversation + tools
+  ↓
+handleLlmResponse(response)
+  ├─ Tool calls? → executeToolsAndContinue()
+  │    ├─ Execute via MCP
+  │    ├─ Add results to conversation
+  │    └─ Call LLM again (loop)
+  ├─ Specialist invite? → inviteSpecialist()
+  ├─ IGNORE? → Remove from context
+  └─ RESPOND? → postResponse()
+      └─ Resolve tags (@mentions, #activities)
+      └─ Send via messenger.send
+      └─ Burn tokens (fire-and-forget)
+```
+
+---
+
+## Tool Execution Pipeline
+
+```typescript
+// 1. LLM returns tool_use blocks
+const toolUseBlocks = response.content.filter(b => b.type === "tool_use");
+
+// 2. Preprocess each tool input (inject context)
+preprocessToolInput(toolName, input) {
+  // Inject discussionId, sourceActivityId, etc.
+  return modified_input;
+}
+
+// 3. Execute via MCP service
+const toolResults = await toolExecutor.executeTools(toolUseBlocks, {
+  session,
+  preprocessToolInput
+});
+
+// 4. Add results to conversation
+conversation.push({ role: "user", content: toolResults });
+
+// 5. Call LLM again with results
+// 6. Track tokens per response
+```
+
+**Cost Concern:** Each tool response (workflow schemas, activity lists) adds input tokens at model rate.
+
+---
+
+## Token Billing
+
+**Pricing (Claude Haiku 4.5):**
+```typescript
+const HAIKU_PRICING = {
+  inputPerMillion: 1.00,
+  outputPerMillion: 5.00,
+  cacheWritePerMillion: 1.25,  // 25% more than input
+  cacheReadPerMillion: 0.10,   // 90% discount
+};
+```
+
+**Normalized Token Formula:**
+```
+normalizedTokens =
+  inputTokens * 0.20 +
+  outputTokens * 1.0 +
+  cacheCreationTokens * 0.25 +
+  cacheReadTokens * 0.02
+```
+
+**API Calls:**
+- `v3.mcp.getTokenBalance(workspaceId)` - Balance check before session
+- `v3.mcp.deductTokens({...})` - Fire-and-forget token burn
+
+**Graceful Degradation:**
+- Balance check returns "OK" if service unavailable
+- Token burn is async, doesn't block response
+
+**Cost Optimization:**
+Set `DISABLE_SESSION_LOG=true` to save ~1620 tokens per conversation:
+- Skips SESSION_LOG persistence (20 tokens)
+- Uses truncation instead of LLM summarization (~1000 tokens)
+- Skips metadata extraction (~600 tokens)
+- Uses discussion messages for cold start (FREE)
+
+---
+
+## Specialist Coordination
+
+**HAL can invoke specialists via XML pattern:**
+```xml
+<invite specialist="key">handoff context</invite>
+```
+
+**Specialist Registry:**
+```typescript
+specialists: Map<string, Specialist>
+activeSpecialistsInDiscussion: Map<string, Set<string>>
+```
+
+**Handoff Flow:**
+1. HAL detects task needs specialist
+2. Calls `invite_discussion_members` with specialist userId
+3. Posts handoff message with `[hailerTag|Name](userId)` mention
+4. Specialist receives notification, joins discussion
+
+---
+
+## Per-Discussion Isolation
+
+**Conversation Manager:**
+- LRU cache of 100 most recent discussions
+- Each discussion has independent conversation history
+- Auto-truncates when >50 messages (keeps last 30)
+- Prevents context pollution across chats
+
+**Cost Optimization (`DISABLE_SESSION_LOG=true`):**
+- Cold start: Fetches discussion messages (FREE) instead of SESSION_LOG
+- Context overflow: Truncates (0 tokens) instead of LLM summarization (~1000 tokens)
+- Session end: Skips persistence (saves 20 tokens + ~600 metadata extraction)
+
+**Session Tracking:**
+```typescript
+interface ActivitySession {
+  discussionId: string;
+  activityId: string;
+  activityName: string;
+  metrics: { inputTokens, outputTokens, cacheTokens, apiCalls };
+  conversation: string[];  // ["SenderName: message preview"]
+  actions: string[];       // ["Responded", "Executed tool X"]
+}
+```
+
+**Idle Cleanup:**
+- Timer every 30 seconds
+- Sessions inactive 1 hour auto-flushed
+- Flush writes to Session Log workflow
+
+---
+
+## Cross-Discussion Memory
+
+**Context Persistence (5 min TTL):**
+```typescript
+lastKnownActivityId: string | null;
+lastKnownActivityTime: number;
+```
+
+**Used for:**
+- Auto-inject `sourceActivityId` in `join_discussion`
+- "Came from" wormhole links when inviting users
+- Timeout-based expiration
+
+---
+
+## Bot Manager
+
+**Connection Pool:**
+```typescript
+class MultiBotManager {
+  botClients: Map<string, BotClient>;
+
+  initializeBotClient(email, password, apiKey): Promise<string>
+  removeBotClient(userId): Promise<void>
+  getBotClient(userId): BotClient | undefined
+}
+```
+
+**BotClient Structure:**
+```typescript
+interface BotClient {
+  userId: string;
+  firstName: string;
+  lastName: string;
+  config: BotClientConfig;
+  client: HailerClient;
+  signalHandler: SignalHandler;
+  workspaceCache?: WorkspaceCache;
+}
+```
+
+**Initialization:**
+1. Load bot configs
+2. Create HailerClient via API key
+3. Fetch workspace cache (`v2.core.init`)
+4. Check Agent Directory for custom display names
+5. Register signal handlers
+
+---
+
+## Agent Directory Discovery
+
+**Schema Discovery:**
+1. List all workflows
+2. Find "Agent Directory" workflow
+3. Extract "Deployed"/"Retired" phases
+4. Map field keys to field IDs
+5. Cache for dynamic lookups
+
+**BotContext Singleton (per workspace):**
+```typescript
+getBotContext(workspaceId) → {
+  agentDirectoryWorkflowId,
+  deployedPhaseId,
+  retiredPhaseId,
+  fields: { hailerProfile, email, password, botType }
+}
+```
+
+---
+
+## System Prompt Caching (50% cost reduction)
+
+**HAL uses Anthropic prompt caching:**
+- Static content (identity, specialist list template) → `ephemeral` cache
+- Dynamic content (current specialists, pending fixes) → appended fresh
+- Format: `Anthropic.TextBlockParam[]`
+
+---
+
+## Error Handling
+
+| Error Type | Handling |
+|------------|----------|
+| Tool execution | Return `is_error: true`, LLM sees and can retry |
+| Message processing | Log, remove from context, silent fail |
+| Billing errors | Graceful degradation, return "OK" |
+| Signal errors | Early dedup, invalid messages cleaned |
+
+---
+
+## Structured Outputs Mode (Token Optimization)
+
+**Problem:** Native tool definitions cost ~100K tokens per request (22 tool schemas sent every API call).
+
+**Solution:** Use Anthropic's structured outputs beta to replace tool schemas with compact JSON action schema.
+
+**Enable:**
+```bash
+USE_STRUCTURED_OUTPUTS=true npm run daemon
+```
+
+**Key Files:**
+| File | Purpose |
+|------|---------|
+| `src/agents/shared/schemas/action-schema.ts` | Action type definitions, JSON schema |
+| `src/agents/shared/services/structured-output-executor.ts` | Action parsing and execution |
+
+**How It Works:**
+1. Instead of `tools: [...]` array, uses `output_format: { type: "json_schema", schema: {...} }`
+2. Claude outputs JSON with action type and params
+3. `StructuredOutputExecutor` parses and executes via existing MCP tools
+4. Multi-turn loops work the same way
+
+**Action Schema:**
+```typescript
+interface ActionOutput {
+  thinking?: string;           // Brief reasoning
+  action: BotAction;           // "respond" | "list_activities" | etc.
+  params?: Record<string, unknown>;  // Tool-specific params
+  response_text?: string;      // For "respond" action
+  specialist_key?: string;     // For "invite_specialist" action
+}
+```
+
+**Savings:**
+- ~100K tokens saved per request
+- At Haiku rates ($0.80/M): ~$0.08 saved per request
+- 1000 requests/day = ~$80/day saved
+
+**Trade-offs:**
+- Beta feature (may have edge cases)
+- Grammar compilation on first use (cached for 24h)
+- Slightly different error handling
+
+---
+
+## Key Design Patterns
+
+1. **Per-Discussion Isolation** - Independent conversation per chat
+2. **Multi-Tenant** - BotContext, schema cache, billing per workspace
+3. **Signal-Driven** - Listen to `messenger.new`, early dedup
+4. **Graceful Degradation** - Billing/memory failures don't block
+5. **Fire-and-Forget Billing** - Async token burn, no blocking
+6. **Tool Preprocessing** - Inject context before MCP execution
+7. **Structured Outputs** - Optional token optimization via JSON action schema

package/.claude/skills/publish-hailer-app/SKILL.md

@@ -82,12 +82,23 @@ Required structure:
 
 ### Step 4: Publish
 
+**Option 1: Production Only**
 ```javascript
 publish_hailer_app({
   projectDirectory: "/path/to/app"
 })
 ```
 
+**Option 2: Production + Marketplace**
+```javascript
+publish_hailer_app({
+  projectDirectory: "/path/to/app",
+  publishToMarket: true
+})
+```
+
+**IMPORTANT:** The `publishToMarket: true` parameter is REQUIRED to publish the app to the Hailer Marketplace. Without it, the app is published only to your production environment.
+
 ### Step 5: Verify
 
 ```javascript

package/dist/app.d.ts

@@ -1,4 +1,4 @@
 import { Core } from './core';
-declare const core: Core;
+declare const core: Core | null;
 export default core;
 //# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -3,7 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("./core");
 const config_1 = require("./config");
 const logger_1 = require("./lib/logger");
+const tool_registry_1 = require("./mcp/tool-registry");
+const stdio_server_1 = require("./stdio-server");
 const logger = (0, logger_1.createLogger)({ component: 'app' });
+// Detect transport mode:
+// - MCP_TRANSPORT=stdio - explicit stdio mode
+// - MCP_TRANSPORT=http - explicit HTTP mode
+// - No TTY on stdin - Claude Desktop spawned process, use stdio
+// - TTY on stdin - manual terminal run, use HTTP
+const transportMode = process.env.MCP_TRANSPORT || (process.stdin.isTTY ? 'http' : 'stdio');
+const isStdioMode = transportMode === 'stdio';
+logger.info('Transport mode detected', {
+    mode: transportMode,
+    isTTY: process.stdin.isTTY,
+    isStdioMode
+});
 const file_1 = require("./mcp/tools/file");
 const activity_1 = require("./mcp/tools/activity");
 const discussion_1 = require("./mcp/tools/discussion");
@@ -13,79 +27,87 @@ const insight_1 = require("./mcp/tools/insight");
 const app_1 = require("./mcp/tools/app");
 // Bot config and bug-fixer tools are dynamically imported only when MCP_CLIENT_ENABLED=true
 // This allows the npm package to work without these modules
-const core = new core_1.Core();
+// For stdio mode, create standalone ToolRegistry
+// For HTTP mode, use Core which has its own ToolRegistry
+const toolRegistry = isStdioMode ? new tool_registry_1.ToolRegistry({ enableNuclearTools: config_1.environment.ENABLE_NUCLEAR_TOOLS }) : null;
+const core = isStdioMode ? null : new core_1.Core();
+// Helper to add tool to the appropriate registry
+const addTool = (tool) => {
+    if (toolRegistry) {
+        toolRegistry.addTool(tool);
+    }
+    else if (core) {
+        core.addTool(tool);
+    }
+};
 logger.info('Registering tools...');
 logger.info('Nuclear tools status', { enabled: config_1.environment.ENABLE_NUCLEAR_TOOLS });
-core.addTool(file_1.uploadFilesTool);
-core.addTool(file_1.downloadFileTool);
-core.addTool(activity_1.listActivitiesTool);
-core.addTool(activity_1.showActivityByIdTool);
-core.addTool(activity_1.createActivityTool);
-core.addTool(activity_1.updateActivityTool);
-// core.addTool(searchActivitiesTool);
-// core.addTool(filterActivitiesTool);
-// core.addTool(activityToolsGuideTool);
-core.addTool(discussion_1.listMyDiscussionsTool);
-core.addTool(discussion_1.fetchDiscussionMessagesTool);
-core.addTool(discussion_1.fetchPreviousDiscussionMessagesTool);
-core.addTool(discussion_1.joinDiscussionTool);
-core.addTool(discussion_1.leaveDiscussionTool);
-core.addTool(discussion_1.addDiscussionMessageTool);
-core.addTool(discussion_1.inviteDiscussionMembersTool);
-core.addTool(discussion_1.getActivityFromDiscussionTool);
-core.addTool(user_1.searchWorkspaceUsersTool);
-// core.addTool(hailerGetInitTool);
-// core.addTool(validateUserIdTool);
-core.addTool(workflow_1.getWorkflowSchemaTool);
-core.addTool(workflow_1.listWorkflowPhasesTool);
-core.addTool(workflow_1.listWorkflowsTool);
-core.addTool(workflow_1.installWorkflowTool);
+addTool(file_1.uploadFilesTool);
+addTool(file_1.downloadFileTool);
+addTool(activity_1.listActivitiesTool);
+addTool(activity_1.showActivityByIdTool);
+addTool(activity_1.createActivityTool);
+addTool(activity_1.updateActivityTool);
+addTool(discussion_1.listMyDiscussionsTool);
+addTool(discussion_1.fetchDiscussionMessagesTool);
+addTool(discussion_1.fetchPreviousDiscussionMessagesTool);
+addTool(discussion_1.joinDiscussionTool);
+addTool(discussion_1.leaveDiscussionTool);
+addTool(discussion_1.addDiscussionMessageTool);
+addTool(discussion_1.inviteDiscussionMembersTool);
+addTool(discussion_1.getActivityFromDiscussionTool);
+addTool(user_1.searchWorkspaceUsersTool);
+addTool(user_1.getWorkspaceBalanceTool);
+addTool(workflow_1.getWorkflowSchemaTool);
+addTool(workflow_1.listWorkflowPhasesTool);
+addTool(workflow_1.listWorkflowsTool);
+addTool(workflow_1.installWorkflowTool);
 if (config_1.environment.ENABLE_NUCLEAR_TOOLS) {
-    core.addTool(workflow_1.removeWorkflowTool);
+    addTool(workflow_1.removeWorkflowTool);
 }
-core.addTool(workflow_1.updateWorkflowFieldTool);
-core.addTool(workflow_1.updateWorkflowPhaseTool);
-core.addTool(workflow_1.testFunctionFieldTool);
-core.addTool(workflow_1.listWorkflowsMinimalTool);
-core.addTool(workflow_1.countActivitiesTool);
-core.addTool(insight_1.createInsightTool);
-core.addTool(insight_1.previewInsightTool);
-core.addTool(insight_1.getInsightDataTool);
-core.addTool(insight_1.updateInsightTool);
+addTool(workflow_1.updateWorkflowFieldTool);
+addTool(workflow_1.updateWorkflowPhaseTool);
+addTool(workflow_1.testFunctionFieldTool);
+addTool(workflow_1.listWorkflowsMinimalTool);
+addTool(workflow_1.countActivitiesTool);
+addTool(insight_1.createInsightTool);
+addTool(insight_1.previewInsightTool);
+addTool(insight_1.getInsightDataTool);
+addTool(insight_1.updateInsightTool);
 if (config_1.environment.ENABLE_NUCLEAR_TOOLS) {
-    core.addTool(insight_1.removeInsightTool);
+    addTool(insight_1.removeInsightTool);
 }
-core.addTool(insight_1.listInsightsTool);
-core.addTool(app_1.createAppTool);
-core.addTool(app_1.listAppsTool);
-core.addTool(app_1.updateAppTool);
+addTool(insight_1.listInsightsTool);
+addTool(app_1.createAppTool);
+addTool(app_1.listAppsTool);
+addTool(app_1.updateAppTool);
 if (config_1.environment.ENABLE_NUCLEAR_TOOLS) {
-    core.addTool(app_1.removeAppTool);
+    addTool(app_1.removeAppTool);
 }
-core.addTool(app_1.addAppMemberTool);
-core.addTool(app_1.removeAppMemberTool);
-core.addTool(app_1.scaffoldHailerAppTool);
-core.addTool(app_1.publishHailerAppTool);
+addTool(app_1.addAppMemberTool);
+addTool(app_1.removeAppMemberTool);
+addTool(app_1.scaffoldHailerAppTool);
+addTool(app_1.publishHailerAppTool);
 // Marketplace template tools
-core.addTool(app_1.listTemplatesTool);
-core.addTool(app_1.createTemplateTool);
-core.addTool(app_1.installTemplateTool);
-core.addTool(app_1.getTemplateTool);
-core.addTool(app_1.publishTemplateTool);
-core.addTool(app_1.getProductTool);
-core.addTool(app_1.getProductManifestTool);
+addTool(app_1.listTemplatesTool);
+addTool(app_1.createTemplateTool);
+addTool(app_1.installTemplateTool);
+addTool(app_1.getTemplateTool);
+addTool(app_1.publishTemplateTool);
+addTool(app_1.getProductTool);
+addTool(app_1.getProductManifestTool);
 // Marketplace app tools
-core.addTool(app_1.publishAppTool);
-core.addTool(app_1.installMarketplaceAppTool);
+addTool(app_1.publishAppTool);
+addTool(app_1.installMarketplaceAppTool);
 // Bot-internal tools - dynamically imported only when MCP_CLIENT_ENABLED=true
 // This allows npm package to work without bot-config and bug-fixer modules
-if (config_1.environment.MCP_CLIENT_ENABLED) {
+if (config_1.environment.MCP_CLIENT_ENABLED && !isStdioMode) {
     // Dynamic import bot-config tools
     const { listBotsConfigTool, enableBotTool, disableBotTool, checkSpecialistStatusTool } = require('./bot-config');
-    core.addTool(listBotsConfigTool);
-    core.addTool(enableBotTool);
-    core.addTool(disableBotTool);
-    core.addTool(checkSpecialistStatusTool);
+    addTool(listBotsConfigTool);
+    addTool(enableBotTool);
+    addTool(disableBotTool);
+    addTool(checkSpecialistStatusTool);
     // Dynamic import bug-fixer tools
     const { 
     // Low-level tools
@@ -93,34 +115,44 @@ if (config_1.environment.MCP_CLIENT_ENABLED) {
     // High-level workflow tools (LLM-driven)
     bugFixerAnalyzeBugTool, bugFixerStartFixTool, bugFixerMarkDeclinedTool, bugFixerPublishFixTool, bugFixerRetryFixTool, markBugDeclinedTool, markBugFixedTool } = require('./mcp/tools/bug-fixer-tools');
     // Low-level tools
-    core.addTool(bugFixerFindAppTool);
-    core.addTool(bugFixerListFilesTool);
-    core.addTool(bugFixerReadFileTool);
-    core.addTool(bugFixerWriteFileTool);
-    core.addTool(bugFixerApplyFixTool);
-    core.addTool(bugFixerRunBuildTool);
-    core.addTool(bugFixerGitStatusTool);
-    core.addTool(bugFixerGitPullTool);
-    core.addTool(bugFixerGitCommitTool);
-    core.addTool(bugFixerGitPushTool);
-    core.addTool(bugFixerGitRevertTool);
-    core.addTool(bugFixerPublishAppTool);
+    addTool(bugFixerFindAppTool);
+    addTool(bugFixerListFilesTool);
+    addTool(bugFixerReadFileTool);
+    addTool(bugFixerWriteFileTool);
+    addTool(bugFixerApplyFixTool);
+    addTool(bugFixerRunBuildTool);
+    addTool(bugFixerGitStatusTool);
+    addTool(bugFixerGitPullTool);
+    addTool(bugFixerGitCommitTool);
+    addTool(bugFixerGitPushTool);
+    addTool(bugFixerGitRevertTool);
+    addTool(bugFixerPublishAppTool);
     // High-level workflow tools (LLM-driven)
-    core.addTool(bugFixerAnalyzeBugTool);
-    core.addTool(bugFixerStartFixTool);
-    core.addTool(bugFixerMarkDeclinedTool);
-    core.addTool(bugFixerPublishFixTool);
-    core.addTool(bugFixerRetryFixTool);
-    core.addTool(markBugDeclinedTool);
-    core.addTool(markBugFixedTool);
+    addTool(bugFixerAnalyzeBugTool);
+    addTool(bugFixerStartFixTool);
+    addTool(bugFixerMarkDeclinedTool);
+    addTool(bugFixerPublishFixTool);
+    addTool(bugFixerRetryFixTool);
+    addTool(markBugDeclinedTool);
+    addTool(markBugFixedTool);
     logger.info('Bot-internal tools registered (MCP_CLIENT_ENABLED=true)');
 }
 logger.info('All tools registered successfully');
-// Start the application
-core.start().catch((error) => {
-    logger.error('Failed to start Hailer MCP application', error);
-    process.exit(1);
-});
-// Export core for testing and external access
+// Start the appropriate server based on transport mode
+if (isStdioMode && toolRegistry) {
+    // Stdio mode for Claude Desktop
+    (0, stdio_server_1.startStdioServer)(toolRegistry).catch((error) => {
+        logger.error('Failed to start stdio MCP server', error);
+        process.exit(1);
+    });
+}
+else if (core) {
+    // HTTP mode for other clients
+    core.start().catch((error) => {
+        logger.error('Failed to start Hailer MCP application', error);
+        process.exit(1);
+    });
+}
+// Export core for testing and external access (may be null in stdio mode)
 exports.default = core;
 //# sourceMappingURL=app.js.map

package/dist/bot/chat-bot.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Simple Hailer Chat Bot
+ *
+ * Listens to discussions via WebSocket, responds using Anthropic Claude API
+ * with access to ALL MCP tools via the ToolRegistry.
+ */
+interface BotConfig {
+    email: string;
+    password: string;
+    apiBaseUrl: string;
+    anthropicApiKey: string;
+    botName?: string;
+    model?: string;
+}
+export declare class HailerChatBot {
+    private clientManager;
+    private hailerApi;
+    private anthropic;
+    private botUserId;
+    private apiKey;
+    private config;
+    private toolRegistry;
+    constructor(config: BotConfig);
+    private registerAllTools;
+    start(): Promise<void>;
+    private handleMessage;
+    private generateResponse;
+    stop(): Promise<void>;
+}
+export default HailerChatBot;
+//# sourceMappingURL=chat-bot.d.ts.map