@hailer/mcp 0.1.14 → 0.1.16

package/dist/agents/hal/definitions.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Specialist Bot Configuration
+ *
+ * Defines specialist bots that can be invited by the orchestrator (HAL)
+ * when tasks are too complex for general handling.
+ *
+ * Each specialist has:
+ * - Trigger patterns: When HAL should consider inviting them
+ * - Expertise areas: What they're good at
+ * - System prompt: How they behave when invited
+ */
+export interface Specialist {
+    /** Definition name (e.g., "Hailer Expert") - used internally */
+    name: string;
+    /** Actual Hailer user display name (e.g., "Claude Terminal") - used for @mentions */
+    displayName?: string;
+    /** Hailer user ID of this bot (set at runtime from config) */
+    botUserId?: string;
+    /** Email of this bot (for matching with config) */
+    botEmail: string;
+    /** What this specialist is good at */
+    expertise: string[];
+    /** Regex patterns that trigger consideration of this specialist */
+    triggerPatterns: RegExp[];
+    /** Keywords that suggest this specialist (less strict than patterns) */
+    triggerKeywords: string[];
+    /** System prompt for this specialist when active */
+    systemPrompt: string;
+    /** Model to use (defaults to parent config) */
+    model?: string;
+}
+/**
+ * Registry of available specialists
+ * Key is the specialist identifier used internally
+ */
+export declare const SPECIALISTS: Record<string, Specialist>;
+/**
+ * Find a specialist that matches the given message content
+ * Returns the specialist if patterns match, null otherwise
+ */
+export declare function findMatchingSpecialist(content: string): Specialist | null;
+/**
+ * Check if content contains keywords suggesting a specialist might help
+ * Less strict than pattern matching - used for secondary consideration
+ */
+export declare function hasSpecialistKeywords(content: string, specialist: Specialist): boolean;
+/**
+ * Get specialist by key
+ */
+export declare function getSpecialist(key: string): Specialist | undefined;
+/**
+ * Get all specialist keys
+ */
+export declare function getSpecialistKeys(): string[];
+//# sourceMappingURL=definitions.d.ts.map

package/dist/agents/hal/definitions.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * Specialist Bot Configuration
+ *
+ * Defines specialist bots that can be invited by the orchestrator (HAL)
+ * when tasks are too complex for general handling.
+ *
+ * Each specialist has:
+ * - Trigger patterns: When HAL should consider inviting them
+ * - Expertise areas: What they're good at
+ * - System prompt: How they behave when invited
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPECIALISTS = void 0;
+exports.findMatchingSpecialist = findMatchingSpecialist;
+exports.hasSpecialistKeywords = hasSpecialistKeywords;
+exports.getSpecialist = getSpecialist;
+exports.getSpecialistKeys = getSpecialistKeys;
+/**
+ * Registry of available specialists
+ * Key is the specialist identifier used internally
+ */
+exports.SPECIALISTS = {
+    giuseppe: {
+        name: "Giuseppe",
+        botEmail: "", // Set from config at runtime (uses same bot as orchestrator for now)
+        expertise: [
+            "bug fixing",
+            "app debugging",
+            "React/TypeScript fixes",
+            "Hailer app development",
+            "automated code repair",
+        ],
+        triggerPatterns: [
+            // Bug reports
+            /bug\s+(report|in|with|found)/i,
+            /report\s+(a\s+)?bug/i,
+            /found\s+(a\s+)?bug/i,
+            /there('s|\s+is)\s+(a\s+)?bug/i,
+            // Fix requests
+            /fix\s+(the|this|my)\s+(bug|issue|problem|app)/i,
+            /can\s+you\s+fix/i,
+            /please\s+fix/i,
+            // App issues
+            /app\s+(is\s+)?(broken|not\s+working|crashing|laggy)/i,
+            /(broken|crashing|laggy)\s+app/i,
+            // Giuseppe mentions
+            /giuseppe/i,
+            /auto.?fix/i,
+        ],
+        triggerKeywords: [
+            "bug",
+            "fix",
+            "broken",
+            "issue",
+            "error",
+            "crash",
+            "laggy",
+            "not working",
+            "giuseppe",
+        ],
+        systemPrompt: `<identity>
+You are Giuseppe - the autonomous bug fixing specialist.
+You were designed to automatically detect, analyze, and fix bugs in Hailer apps.
+</identity>
+
+<capabilities>
+**Automatic Bug Detection:**
+- I monitor the "Bug Reports" workflow for new bugs
+- When a bug is detected, I automatically:
+  1. Find the app project
+  2. Analyze the code
+  3. Generate a fix using Claude
+  4. Apply and test the fix
+  5. Ask for approval before publishing
+
+**Bug Report Workflow:**
+- Users create bug reports in the "Bug Reports" workflow
+- I pick them up automatically and start fixing
+- After the fix is ready, I ask the user to test
+- User replies "approved" → I publish to production
+- User replies "denied" → I ask what's wrong and retry
+
+**What I Can Fix:**
+- React/TypeScript compilation errors
+- Hailer app SDK issues
+- UI bugs and layout problems
+- State management issues
+- API integration bugs
+</capabilities>
+
+<how_to_use>
+To report a bug for me to fix:
+1. Create a new activity in the "Bug Reports" workflow
+2. Set the title to include the app name (e.g., "Bug Report - My App")
+3. Describe the bug in detail
+4. I'll automatically pick it up and start working on it!
+
+Or just tell HAL about a bug and ask to create a bug report.
+</how_to_use>
+
+<response_format>
+When asked about bugs or my capabilities:
+- Explain what I can do
+- Offer to create a bug report if they describe a bug
+- Tell them to check the Bug Reports workflow for status
+</response_format>`,
+    },
+    hailerExpert: {
+        name: "Hailer Expert",
+        botEmail: "", // Set from config at runtime
+        expertise: [
+            "workflow creation and management",
+            "activity bulk operations",
+            "insights and SQL reports",
+            "complex data queries",
+            "workflow configuration",
+        ],
+        triggerPatterns: [
+            // Workflow creation
+            /create\s+(a\s+)?(new\s+)?(workflow|pipeline|process|tracker)/i,
+            /set\s+up\s+(a\s+)?(new\s+)?(workflow|pipeline|process)/i,
+            /build\s+(me\s+)?(a\s+)?(workflow|pipeline|crm|tracker)/i,
+            // Insight/report creation
+            /create\s+(a\s+)?(new\s+)?(report|insight|dashboard)/i,
+            /set\s+up\s+(a\s+)?(report|insight|analytics)/i,
+            /build\s+(a\s+)?(report|dashboard)\s+(showing|for)/i,
+            // Bulk operations
+            /create\s+(\d{2,}|multiple|several|many)\s+(activities|tasks|records)/i,
+            /bulk\s+(create|update|import)/i,
+            /import\s+(\d+|these|the)\s+(activities|tasks|records|items)/i,
+            // Complex queries
+            /complex\s+(query|filter|search)/i,
+            /advanced\s+(search|filter)/i,
+            // Multi-step operations
+            /(and|then|also)\s+(create|set up|add)\s+(a\s+)?(report|insight|workflow)/i,
+        ],
+        triggerKeywords: [
+            "workflow",
+            "pipeline",
+            "insight",
+            "report",
+            "dashboard",
+            "bulk",
+            "import",
+            "phases",
+            "stages",
+        ],
+        systemPrompt: `<identity>
+You are the Hailer Expert - a specialized assistant for Hailer workspace operations.
+You were invited to this discussion by HAL to help with a specific task.
+</identity>
+
+<capabilities>
+You have access to these MCP tools:
+
+**Workflow Management:**
+- list_workflows, list_workflows_minimal - See available workflows
+- list_workflow_phases - See phases in a workflow
+- get_workflow_schema - See fields and structure
+- install_workflow(workflowTemplates: [{name, fields: {_1000: {label, type, key}}, phases: {_2000: {name, isInitial}}}]) - CREATE workflows from scratch (NOT marketplace)
+- update_workflow_field - Modify workflow fields
+- update_workflow_phase - Modify phases
+
+**Activity Operations:**
+- list_activities(workflowId, phaseId, filters?, fields?, search?, limit?) - Query activities
+- show_activity_by_id(activityId) - Get activity details
+- create_activity(workflowId, name, fields?) OR create_activity(workflowId, activities[{name, fields}]) - Create single/bulk
+- update_activity(activityId, name?, fields?, phaseId?) - Update SINGLE activity
+- update_activity(activities: [{_id, name?, fields?, phaseId?}]) - Update BULK (3+ activities)
+- count_activities(workflowId, phaseId?) - Count activities
+
+**CRITICAL for update_activity:**
+- SINGLE: use "activityId" parameter (NOT "_id")
+- BULK: use "activities" array, each object MUST have "_id" (the activity ID)
+
+**Insights (SQL Reports):**
+- list_insights - See existing insights
+- create_insight - Create SQL-like reports
+- preview_insight - Test SQL queries
+- get_insight_data - Execute and get results
+
+**Other:**
+- search_workspace_users - Find users
+- Discussion tools for chat
+</capabilities>
+
+<protocol>
+1. Read HAL's handoff message carefully - it contains the task context
+2. Plan the operations needed
+3. Execute using MCP tools - NEVER fabricate data
+4. Report back with:
+   - What you did
+   - Results with clickable links (#activityId format)
+   - Any follow-up suggestions
+</protocol>
+
+<response_format>
+When completing a task:
+<respond discussion="DISCUSSION_ID">
+[Brief status emoji + summary]
+
+**What I did:**
+- Step 1: ...
+- Step 2: ...
+
+**Results:**
+[Data, links, or confirmation]
+
+**Next steps (optional):**
+[Suggestions for follow-up]
+</respond>
+</response_format>
+
+<rules>
+- Only respond when @mentioned - you were invited for a specific task
+- Always use tools - never make up data or IDs
+- Use #activityId format for activity links (auto-resolves to names)
+- Be concise and technical
+- If a tool call fails, DO NOT retry with the same parameters - explain the error to the user
+- If you get "activityId is required" error, you forgot to pass the activity ID - fix your parameters
+- Maximum 5 tool calls per task - if you need more, ask the user to break it down
+</rules>`,
+    },
+};
+/**
+ * Find a specialist that matches the given message content
+ * Returns the specialist if patterns match, null otherwise
+ */
+function findMatchingSpecialist(content) {
+    for (const specialist of Object.values(exports.SPECIALISTS)) {
+        // Check trigger patterns (strict match)
+        for (const pattern of specialist.triggerPatterns) {
+            if (pattern.test(content)) {
+                return specialist;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if content contains keywords suggesting a specialist might help
+ * Less strict than pattern matching - used for secondary consideration
+ */
+function hasSpecialistKeywords(content, specialist) {
+    const contentLower = content.toLowerCase();
+    const keywordCount = specialist.triggerKeywords.filter((kw) => contentLower.includes(kw.toLowerCase())).length;
+    // Require at least 2 keywords for a soft match
+    return keywordCount >= 2;
+}
+/**
+ * Get specialist by key
+ */
+function getSpecialist(key) {
+    return exports.SPECIALISTS[key];
+}
+/**
+ * Get all specialist keys
+ */
+function getSpecialistKeys() {
+    return Object.keys(exports.SPECIALISTS);
+}
+//# sourceMappingURL=definitions.js.map

package/dist/agents/hal/index.d.ts

@@ -0,0 +1,3 @@
+export { OrchestratorDaemon, OrchestratorDaemonConfig } from './daemon';
+export { SPECIALISTS, Specialist } from './definitions';
+//# sourceMappingURL=index.d.ts.map

package/dist/agents/hal/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPECIALISTS = exports.OrchestratorDaemon = void 0;
+var daemon_1 = require("./daemon");
+Object.defineProperty(exports, "OrchestratorDaemon", { enumerable: true, get: function () { return daemon_1.OrchestratorDaemon; } });
+var definitions_1 = require("./definitions");
+Object.defineProperty(exports, "SPECIALISTS", { enumerable: true, get: function () { return definitions_1.SPECIALISTS; } });
+//# sourceMappingURL=index.js.map

package/dist/agents/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hailer MCP Agents
+ *
+ * Each agent has its own folder with related code:
+ * - hal/       - HAL orchestrator (coordinates specialists)
+ * - giuseppe/  - Giuseppe bug fixer (autonomous code repair)
+ * - hailer-expert/ - Hailer workspace specialist
+ * - shared/    - Base classes and services used by all agents
+ */
+export { ChatAgentDaemon, ChatAgentDaemonConfig } from './shared/base';
+export { SpecialistDaemon, SpecialistDaemonConfig } from './shared/specialist';
+export * from './shared/types';
+export { OrchestratorDaemon, OrchestratorDaemonConfig } from './hal';
+export { SPECIALISTS, Specialist } from './hal';
+export { GiuseppeModule } from './giuseppe';
+export { DaemonManager, DaemonManagerOptions, createDaemonManager, CreateDaemonManagerOptions, startDaemonMode } from './factory';
+export { MultiBotManager, BotClient } from './bot-manager';
+//# sourceMappingURL=index.d.ts.map

package/dist/agents/index.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Hailer MCP Agents
+ *
+ * Each agent has its own folder with related code:
+ * - hal/       - HAL orchestrator (coordinates specialists)
+ * - giuseppe/  - Giuseppe bug fixer (autonomous code repair)
+ * - hailer-expert/ - Hailer workspace specialist
+ * - shared/    - Base classes and services used by all agents
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiBotManager = exports.startDaemonMode = exports.createDaemonManager = exports.DaemonManager = exports.GiuseppeModule = exports.SPECIALISTS = exports.OrchestratorDaemon = exports.SpecialistDaemon = exports.ChatAgentDaemon = void 0;
+// Shared
+var base_1 = require("./shared/base");
+Object.defineProperty(exports, "ChatAgentDaemon", { enumerable: true, get: function () { return base_1.ChatAgentDaemon; } });
+var specialist_1 = require("./shared/specialist");
+Object.defineProperty(exports, "SpecialistDaemon", { enumerable: true, get: function () { return specialist_1.SpecialistDaemon; } });
+__exportStar(require("./shared/types"), exports);
+// HAL (Orchestrator)
+var hal_1 = require("./hal");
+Object.defineProperty(exports, "OrchestratorDaemon", { enumerable: true, get: function () { return hal_1.OrchestratorDaemon; } });
+var hal_2 = require("./hal");
+Object.defineProperty(exports, "SPECIALISTS", { enumerable: true, get: function () { return hal_2.SPECIALISTS; } });
+// Giuseppe (Bug Fixer)
+var giuseppe_1 = require("./giuseppe");
+Object.defineProperty(exports, "GiuseppeModule", { enumerable: true, get: function () { return giuseppe_1.GiuseppeModule; } });
+// Factory
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "DaemonManager", { enumerable: true, get: function () { return factory_1.DaemonManager; } });
+Object.defineProperty(exports, "createDaemonManager", { enumerable: true, get: function () { return factory_1.createDaemonManager; } });
+Object.defineProperty(exports, "startDaemonMode", { enumerable: true, get: function () { return factory_1.startDaemonMode; } });
+var bot_manager_1 = require("./bot-manager");
+Object.defineProperty(exports, "MultiBotManager", { enumerable: true, get: function () { return bot_manager_1.MultiBotManager; } });
+//# sourceMappingURL=index.js.map

package/dist/agents/shared/base.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Chat Agent Daemon
+ *
+ * A persistent LLM conversation that monitors all workspace chats.
+ * The LLM maintains context across messages and decides what to respond to.
+ *
+ * Architecture:
+ * - One daemon per bot client
+ * - Subscribes to ALL messenger.new signals (not filtered)
+ * - LLM sees every message with priority markers
+ * - LLM decides: RESPOND / IGNORE / ACTION
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { BotClient } from "../bot-manager";
+import { HailerSignal } from "../../mcp/signal-handler";
+import { Logger } from "../../lib/logger";
+import { ToolSchemaLoader, ToolIndexEntry } from "./tool-schema-loader";
+import { ToolInput, McpToolResult } from "./types";
+import { AgentRegistryService } from "./services/agent-registry";
+import { ConversationManager, ConversationMessage } from "./services/conversation-manager";
+import { McpClientService } from "./services/mcp-client";
+import { MessageFormatterService } from "./services/message-formatter";
+import { MessageClassifier } from "./services/message-classifier";
+import { SessionLoggerService } from "./services/session-logger";
+import { ToolExecutor } from "./services/tool-executor";
+import { WorkspaceSchemaCacheService } from "./services/workspace-schema-cache";
+import { SessionMetrics, ActivitySession, MessagePriority, IncomingMessage, ConversationState } from "./types";
+export type { IncomingMessage, MessagePriority, SessionMetrics, ActivitySession };
+export interface ChatAgentDaemonConfig {
+    botClient: BotClient;
+    mcpServerUrl: string;
+    anthropicApiKey: string;
+    model?: string;
+    maxContextMessages?: number;
+}
+export declare class ChatAgentDaemon {
+    protected logger: Logger;
+    protected client: Anthropic;
+    protected botClient: BotClient;
+    protected config: ChatAgentDaemonConfig;
+    protected toolSchemaLoader: ToolSchemaLoader;
+    protected isProcessing: boolean;
+    protected messageQueue: IncomingMessage[];
+    protected processedMessageIds: Set<string>;
+    private typingInterval;
+    private typingDiscussionId;
+    private static TYPING_REFRESH_MS;
+    protected toolIndex: ToolIndexEntry[];
+    protected minimalTools: Anthropic.Tool[];
+    /** Message classifier - handles message extraction and priority classification */
+    protected messageClassifier: MessageClassifier | null;
+    /** Conversation manager - handles per-discussion context and LRU cache */
+    protected conversationManager: ConversationManager | null;
+    /** MCP client service - handles tool schema loading and execution */
+    protected mcpClient: McpClientService | null;
+    /** Tool executor - handles tool execution and write tracking */
+    protected toolExecutor: ToolExecutor | null;
+    /** Agent registration service - handles Agent Directory, Position, Team, etc. */
+    protected registryService: AgentRegistryService | null;
+    /** Message formatting service - handles tag resolution and formatting */
+    protected messageFormatter: MessageFormatterService | null;
+    /** Session logging service - handles activity session tracking */
+    protected sessionLogger: SessionLoggerService | null;
+    /** Workspace schema cache - dynamic workflow/field ID lookup */
+    protected schemaCache: WorkspaceSchemaCacheService | null;
+    /** Current discussion context for tracking */
+    protected currentDiscussionId: string | null;
+    protected currentLinkedActivityId: string | null;
+    /** Unsubscribe function for messenger.new signals */
+    private messengerUnsubscribe;
+    /** Original API key for cleanup - stored at init because botClient.config may change */
+    private originalApiKey;
+    constructor(config: ChatAgentDaemonConfig);
+    /**
+     * Initialize the daemon - load tools and subscribe to signals
+     */
+    initialize(): Promise<void>;
+    /**
+     * Load existing discussions the bot is already a member of
+     * This ensures the bot can respond to messages in discussions it was added to before startup
+     */
+    private loadExistingDiscussions;
+    /**
+     * Extract and classify incoming message from signal
+     * Can be overridden in subclasses to customize filtering
+     */
+    protected extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
+    /**
+     * Handle incoming signal from Hailer
+     */
+    private handleSignal;
+    /**
+     * Process queued messages through the LLM
+     * Note: Uses flag-first pattern to prevent race conditions
+     */
+    private processQueue;
+    /**
+     * Process a single message through the persistent LLM conversation
+     */
+    private processMessage;
+    /**
+     * Format incoming message for LLM consumption
+     */
+    private formatIncomingMessage;
+    /**
+     * Load and inject memory for an activity into conversation context
+     * Called when entering a new discussion that's linked to an activity
+     */
+    private injectMemoryForActivity;
+    /**
+     * Execute tool calls and continue the conversation
+     * Simple passthrough - just execute tools and return results to LLM
+     */
+    protected executeToolsAndContinue(toolUseBlocks: Anthropic.ToolUseBlock[], originalMessage: IncomingMessage): Promise<void>;
+    /**
+     * Handle LLM response
+     * Override in subclasses to customize response handling
+     */
+    protected handleLlmResponse(response: Anthropic.Message, originalMessage: IncomingMessage): Promise<void>;
+    /**
+     * Start typing indicator with auto-refresh interval
+     * Keeps refreshing every 3 seconds until stopTypingIndicator is called
+     */
+    protected startTypingIndicator(discussionId: string): void;
+    /**
+     * Stop typing indicator and clear refresh interval
+     */
+    protected stopTypingIndicator(): void;
+    /**
+     * Send typing signal to Hailer API
+     * API: messenger.set_discussion_typing_state(discussionId, typingState)
+     */
+    private sendTypingSignal;
+    /**
+     * Post a response to a discussion
+     * Automatically converts @mentions and #activity tags to Hailer tags
+     * Includes links metadata required for tags to work
+     */
+    protected postResponse(discussionId: string, content: string): Promise<void>;
+    /**
+     * Get the system prompt for the daemon
+     * MUST be overridden in subclasses
+     */
+    protected getSystemPrompt(): string;
+    /**
+     * Get tools for LLM calls
+     * Override in subclass to add custom tools (like trigger_giuseppe_retry)
+     */
+    protected getTools(): Anthropic.Tool[];
+    /**
+     * Get tool whitelist for this agent
+     * Override in subclass to limit which tools are available
+     * Return null for all tools, or array of tool names
+     */
+    protected getToolWhitelist(): string[] | null;
+    /**
+     * Preprocess tool input before execution
+     * Override in subclass to inject context (e.g., sourceActivityId)
+     * @param toolName - Name of the tool being called
+     * @param input - Original tool input from LLM
+     * @returns Processed input (may be modified)
+     */
+    protected preprocessToolInput(toolName: string, input: ToolInput): ToolInput;
+    /**
+     * Call MCP tool (delegates to McpClientService)
+     * Protected for subclass access
+     */
+    protected callMcpTool(name: string, args: ToolInput): Promise<McpToolResult>;
+    /**
+     * Stop the daemon
+     * Flushes all pending activity sessions before stopping
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current conversation state (for debugging)
+     */
+    getConversationState(): ConversationState;
+    /**
+     * Get full conversation for a specific discussion (for debugging)
+     */
+    getFullConversation(discussionId?: string): ConversationMessage[];
+    /**
+     * Get agent's display name (override in subclass for custom names)
+     * Default implementation uses the actual Hailer user name from BotClient
+     */
+    protected getAgentName(): {
+        firstName: string;
+        lastName: string;
+    };
+    /**
+     * Get agent's description/system prompt (override in subclass)
+     */
+    protected getAgentDescription(): string;
+    /**
+     * Get default team ID from workspace cache
+     * Returns the first available team, or undefined if no teams exist
+     *
+     * Teams structure in init is: { teams: { workspaceId: { teamId: teamData, ... } } }
+     */
+    protected getDefaultTeamId(): string | undefined;
+    /**
+     * Get agent's Position details (override in subclass for custom positions)
+     */
+    protected getPositionDetails(): {
+        name: string;
+        purpose: string;
+        personaTone: string;
+        coreCapabilities: string;
+        boundaries: string;
+    };
+    /**
+     * Get agent directory ID
+     */
+    getAgentDirectoryId(): string | null;
+}
+//# sourceMappingURL=base.d.ts.map