@vfarcic/dot-ai 0.159.0 → 0.161.0

package/README.md

@@ -87,7 +87,7 @@ Access curated prompts as native slash commands (`/dot-ai:prompt-name`) in your
 📖 [Learn more →](./docs/guides/mcp-prompts-guide.md)
 
 ### ⚡ AI Integration
-Works with Claude Code, Cursor, VS Code via Model Context Protocol. Supports multiple AI providers (Claude, GPT, Gemini) for flexibility and cost optimization.
+Works with Claude Code, Cursor, VS Code via Model Context Protocol. Supports multiple AI providers (Claude, GPT, Gemini, Host LLM) for flexibility and cost optimization.
 📖 [AI Model Configuration](./docs/setup/mcp-setup.md#ai-model-configuration)
 
 ## Quick Start

package/dist/core/ai-provider-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-provider-factory.d.ts","sourceRoot":"","sources":["../../src/core/ai-provider-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,UAAU,EACV,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AA2BjC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAiB;IAC5B;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU;IAuBnD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,aAAa,IAAI,UAAU;IA8ElC;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAMrD;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,IAAI,MAAM,EAAE;IAMxC;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAGxD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAE7C"}
+{"version":3,"file":"ai-provider-factory.d.ts","sourceRoot":"","sources":["../../src/core/ai-provider-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,UAAU,EACV,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AA4BjC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAiB;IAC5B;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU;IA2BnD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,aAAa,IAAI,UAAU;IAgFlC;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAMrD;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,IAAI,MAAM,EAAE;IAMxC;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAGxD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAE7C"}

package/dist/core/ai-provider-factory.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIProviderFactory = void 0;
 exports.createAIProvider = createAIProvider;
 const vercel_provider_1 = require("./providers/vercel-provider");
+const host_provider_1 = require("./providers/host-provider");
 const noop_provider_1 = require("./providers/noop-provider");
 const model_config_1 = require("./model-config");
 /**
@@ -53,6 +54,9 @@ class AIProviderFactory {
      * @throws Error if provider type is unsupported or configuration is invalid
      */
     static create(config) {
+        if (config.provider === model_config_1.CURRENT_MODELS.host) {
+            return new host_provider_1.HostProvider();
+        }
         // Validate configuration
         if (!config.apiKey) {
             throw new Error(`API key is required for ${config.provider} provider`);
@@ -101,6 +105,9 @@ class AIProviderFactory {
             // AWS credentials checked at runtime by AWS SDK (env vars, ~/.aws/credentials, IAM roles)
             apiKey = 'bedrock-uses-aws-credentials';
         }
+        else if (providerType === model_config_1.CURRENT_MODELS.host) {
+            return new host_provider_1.HostProvider();
+        }
         else {
             const apiKeyEnvVar = PROVIDER_ENV_KEYS[providerType];
             if (!apiKeyEnvVar) {

package/dist/core/model-config.d.ts

@@ -13,6 +13,7 @@ export declare const CURRENT_MODELS: {
     readonly kimi: "kimi-k2-0905-preview";
     readonly kimi_thinking: "kimi-k2-thinking";
     readonly xai: "grok-4";
+    readonly host: "host";
     readonly openrouter: "anthropic/claude-haiku-4.5";
     readonly custom: "gpt-5.1-codex";
     readonly amazon_bedrock: "global.anthropic.claude-sonnet-4-20250514-v1:0";

package/dist/core/model-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-config.d.ts","sourceRoot":"","sources":["../../src/core/model-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;CAYjB,CAAC;AAEX;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,OAAO,cAAc,GAAG,MAAM,CAE7E"}
+{"version":3,"file":"model-config.d.ts","sourceRoot":"","sources":["../../src/core/model-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAajB,CAAC;AAEX;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,OAAO,cAAc,GAAG,MAAM,CAE7E"}

package/dist/core/model-config.js

@@ -17,6 +17,7 @@ exports.CURRENT_MODELS = {
     kimi: 'kimi-k2-0905-preview', // PRD #237: Moonshot AI Kimi K2 - standard model with 256K context
     kimi_thinking: 'kimi-k2-thinking', // PRD #237: Moonshot AI Kimi K2 - extended thinking variant
     xai: 'grok-4',
+    host: 'host', // Delegates generation to the client via MCP Sampling
     openrouter: 'anthropic/claude-haiku-4.5', // PRD #194: OpenRouter default model (overridden by AI_MODEL env var)
     custom: 'gpt-5.1-codex', // PRD #194: Custom endpoint default model (overridden by AI_MODEL env var)
     amazon_bedrock: 'global.anthropic.claude-sonnet-4-20250514-v1:0' // PRD #175: Amazon Bedrock default model (overridden by AI_MODEL env var)

package/dist/core/providers/host-provider.d.ts

@@ -0,0 +1,43 @@
+import { AIProvider, AIResponse, AgenticResult, ToolLoopConfig } from '../ai-provider.interface';
+export interface SamplingMessage {
+    role: 'user' | 'assistant';
+    content: {
+        type: 'text';
+        text: string;
+    } | string;
+}
+export interface SamplingResult {
+    content: {
+        type: 'text';
+        text: string;
+    } | string;
+}
+export type SamplingHandler = (messages: SamplingMessage[], systemPrompt?: string, options?: any) => Promise<SamplingResult>;
+export declare class HostProvider implements AIProvider {
+    private static samplingHandler?;
+    private debugMode;
+    constructor();
+    setSamplingHandler(handler: SamplingHandler): void;
+    isInitialized(): boolean;
+    getDefaultModel(): string;
+    getProviderType(): string;
+    getModelName(): string;
+    private logDebugIfEnabled;
+    sendMessage(message: string, operation?: string, evaluationContext?: {
+        user_intent?: string;
+        interaction_id?: string;
+    }): Promise<AIResponse>;
+    /**
+     * Execute a tool loop with the host model
+     *
+     * The tool loop relies on a specific JSON format embedded in markdown code blocks:
+     * ```json
+     * {
+     *   "tool": "toolName",
+     *   "arguments": { ... }
+     * }
+     * ```
+     */
+    toolLoop(config: ToolLoopConfig): Promise<AgenticResult>;
+}
+//# sourceMappingURL=host-provider.d.ts.map

package/dist/core/providers/host-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-provider.d.ts","sourceRoot":"","sources":["../../../src/core/providers/host-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,cAAc,EACf,MAAM,0BAA0B,CAAC;AAkBlC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC;CAClD;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC;CAClD;AAED,MAAM,MAAM,eAAe,GAAG,CAC5B,QAAQ,EAAE,eAAe,EAAE,EAC3B,YAAY,CAAC,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,GAAG,KACV,OAAO,CAAC,cAAc,CAAC,CAAC;AAE7B,qBAAa,YAAa,YAAW,UAAU;IAC7C,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAkB;IACjD,OAAO,CAAC,SAAS,CAAU;;IAM3B,kBAAkB,CAAC,OAAO,EAAE,eAAe;IAI3C,aAAa,IAAI,OAAO;IAIxB,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,MAAM;IAIzB,YAAY,IAAI,MAAM;IAItB,OAAO,CAAC,iBAAiB;IAwBnB,WAAW,CACf,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,MAAkB,EAC7B,iBAAiB,CAAC,EAAE;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GACA,OAAO,CAAC,UAAU,CAAC;IA4HtB;;;;;;;;;;OAUG;IACG,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA0K/D"}

package/dist/core/providers/host-provider.js

@@ -0,0 +1,314 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostProvider = void 0;
+const path = __importStar(require("path"));
+const prompts_1 = require("../../tools/prompts");
+const model_config_1 = require("../model-config");
+const provider_debug_utils_1 = require("./provider-debug-utils");
+const ai_tracing_1 = require("../tracing/ai-tracing");
+const tool_utils_1 = require("./tool-utils");
+class HostProvider {
+    static samplingHandler;
+    debugMode;
+    constructor() {
+        this.debugMode = process.env.DEBUG_DOT_AI === 'true';
+    }
+    setSamplingHandler(handler) {
+        HostProvider.samplingHandler = handler;
+    }
+    isInitialized() {
+        return !!HostProvider.samplingHandler;
+    }
+    getDefaultModel() {
+        return model_config_1.CURRENT_MODELS.host;
+    }
+    getProviderType() {
+        return model_config_1.CURRENT_MODELS.host;
+    }
+    getModelName() {
+        return model_config_1.CURRENT_MODELS.host;
+    }
+    logDebugIfEnabled(operation, prompt, response) {
+        if (!this.debugMode)
+            return null;
+        const debugId = (0, provider_debug_utils_1.generateDebugId)(operation);
+        (0, provider_debug_utils_1.debugLogInteraction)(debugId, prompt, response, operation, this.getProviderType(), this.getModelName(), this.debugMode);
+        return {
+            promptFile: `${debugId}_prompt.md`,
+            responseFile: `${debugId}_response.md`,
+        };
+    }
+    async sendMessage(message, operation = 'generic', evaluationContext) {
+        if (!HostProvider.samplingHandler) {
+            throw new Error('Host provider is not connected to MCP server');
+        }
+        return await (0, ai_tracing_1.withAITracing)({
+            provider: this.getProviderType(),
+            model: this.getModelName(),
+            operation: 'chat',
+        }, async () => {
+            const startTime = Date.now();
+            const messages = [
+                { role: 'user', content: { type: 'text', text: message } },
+            ];
+            try {
+                const result = await HostProvider.samplingHandler(messages, undefined, {
+                    operation,
+                    evaluationContext,
+                });
+                let content = '';
+                if (typeof result.content === 'object' && result.content.type === 'text') {
+                    content = result.content.text;
+                }
+                else if (typeof result.content === 'string') {
+                    content = result.content;
+                }
+                else {
+                    content = JSON.stringify(result.content);
+                }
+                const response = {
+                    content,
+                    usage: {
+                        input_tokens: 0,
+                        output_tokens: 0,
+                    },
+                };
+                const durationMs = Date.now() - startTime;
+                // Debug log the interaction if enabled
+                if (this.debugMode) {
+                    this.logDebugIfEnabled(operation, message, response);
+                    const evaluationMetrics = {
+                        operation,
+                        sdk: this.getProviderType(),
+                        inputTokens: response.usage.input_tokens,
+                        outputTokens: response.usage.output_tokens,
+                        durationMs,
+                        iterationCount: 1,
+                        toolCallCount: 0,
+                        status: 'completed',
+                        completionReason: 'stop',
+                        modelVersion: this.getModelName(),
+                        test_scenario: operation,
+                        ai_response_summary: response.content,
+                        user_intent: evaluationContext?.user_intent || '',
+                        interaction_id: evaluationContext?.interaction_id || '',
+                    };
+                    (0, provider_debug_utils_1.logEvaluationDataset)(evaluationMetrics, this.debugMode);
+                }
+                return response;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (this.debugMode) {
+                    const debugId = (0, provider_debug_utils_1.generateDebugId)(operation);
+                    (0, provider_debug_utils_1.debugLogPromptOnly)(debugId, message, operation, this.getProviderType(), this.getModelName(), this.debugMode);
+                    if (evaluationContext) {
+                        const failureMetrics = {
+                            operation,
+                            user_intent: evaluationContext.user_intent || '',
+                            ai_response_summary: `Error: ${errorMessage}`,
+                            durationMs: Date.now() - startTime,
+                            inputTokens: 0,
+                            outputTokens: 0,
+                            iterationCount: 0,
+                            toolCallCount: 0,
+                            status: 'failed',
+                            completionReason: 'error',
+                            sdk: this.getProviderType(),
+                            modelVersion: this.getModelName(),
+                            test_scenario: operation,
+                            interaction_id: evaluationContext.interaction_id ||
+                                (0, provider_debug_utils_1.generateDebugId)(operation),
+                            failure_analysis: {
+                                failure_type: 'error',
+                                failure_reason: `Host API error: ${errorMessage}`,
+                                time_to_failure: Date.now() - startTime,
+                            },
+                        };
+                        (0, provider_debug_utils_1.logEvaluationDataset)(failureMetrics, this.debugMode);
+                    }
+                }
+                throw new Error(`Host sampling error: ${errorMessage}`);
+            }
+        }, (response) => ({
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+        }));
+    }
+    /**
+     * Execute a tool loop with the host model
+     *
+     * The tool loop relies on a specific JSON format embedded in markdown code blocks:
+     * ```json
+     * {
+     *   "tool": "toolName",
+     *   "arguments": { ... }
+     * }
+     * ```
+     */
+    async toolLoop(config) {
+        if (!HostProvider.samplingHandler) {
+            throw new Error('Host provider is not connected to MCP server');
+        }
+        return await (0, ai_tracing_1.withAITracing)({
+            provider: this.getProviderType(),
+            model: this.getModelName(),
+            operation: 'tool_loop',
+        }, async () => {
+            const maxIterations = config.maxIterations || 20;
+            const messages = [
+                { role: 'user', content: { type: 'text', text: config.userMessage } },
+            ];
+            // Construct system prompt with tool definitions
+            const promptPath = path.join(__dirname, '..', '..', '..', 'prompts', 'host-tools.md');
+            const promptTemplate = (0, prompts_1.loadPromptFile)(promptPath).content;
+            const toolDefinitions = (0, tool_utils_1.formatToolDefinitions)(config.tools);
+            const systemPrompt = config.systemPrompt +
+                '\n\n' +
+                promptTemplate.replace('{{TOOL_DEFINITIONS}}', toolDefinitions);
+            const toolCallsExecuted = [];
+            let iterations = 0;
+            while (iterations < maxIterations) {
+                iterations++;
+                try {
+                    const result = await HostProvider.samplingHandler(messages, systemPrompt, {
+                        operation: config.operation,
+                        evaluationContext: config.evaluationContext,
+                        interaction_id: config.interaction_id,
+                    });
+                    let content = '';
+                    if (typeof result.content === 'object' && result.content.type === 'text') {
+                        content = result.content.text;
+                    }
+                    else if (typeof result.content === 'string') {
+                        content = result.content;
+                    }
+                    else {
+                        content = JSON.stringify(result.content);
+                    }
+                    // Add assistant response to history
+                    messages.push({
+                        role: 'assistant',
+                        content: { type: 'text', text: content },
+                    });
+                    // Check for tool calls
+                    const toolCalls = (0, tool_utils_1.extractToolCalls)(content);
+                    if (toolCalls.length > 0) {
+                        for (const toolCall of toolCalls) {
+                            try {
+                                const toolName = toolCall.tool;
+                                const toolArgs = toolCall.arguments || {};
+                                // Validate tool exists
+                                const toolExists = config.tools.some(t => t.name === toolName);
+                                if (!toolExists) {
+                                    messages.push({
+                                        role: 'user',
+                                        content: {
+                                            type: 'text',
+                                            text: `Unknown tool '${toolName}'. Available tools: ${config.tools.map(t => t.name).join(', ')}`,
+                                        },
+                                    });
+                                    continue;
+                                }
+                                // Execute tool
+                                const toolOutput = await config.toolExecutor(toolName, toolArgs);
+                                toolCallsExecuted.push({
+                                    tool: toolName,
+                                    input: toolArgs,
+                                    output: toolOutput,
+                                });
+                                // Add tool result to history
+                                messages.push({
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: (0, tool_utils_1.formatToolOutput)(toolName, toolOutput),
+                                    },
+                                });
+                            }
+                            catch (executionError) {
+                                messages.push({
+                                    role: 'user',
+                                    content: {
+                                        type: 'text',
+                                        text: `Error executing tool '${toolCall.tool}': ${executionError instanceof Error ? executionError.message : String(executionError)}`,
+                                    },
+                                });
+                            }
+                        }
+                        if (config.onIteration) {
+                            try {
+                                config.onIteration(iterations, toolCallsExecuted);
+                            }
+                            catch (error) {
+                                // Ignore errors in callback
+                            }
+                        }
+                    }
+                    else {
+                        // No tool call, assume final response
+                        return {
+                            finalMessage: content,
+                            iterations,
+                            toolCallsExecuted,
+                            totalTokens: { input: 0, output: 0 },
+                        };
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    throw new Error(`Host sampling error in tool loop: ${message}`);
+                }
+            }
+            const lastMessage = messages[messages.length - 1];
+            const lastContent = typeof lastMessage.content === 'string'
+                ? lastMessage.content
+                : (lastMessage.content?.text ?? '');
+            return {
+                finalMessage: lastContent,
+                iterations,
+                toolCallsExecuted,
+                totalTokens: { input: 0, output: 0 },
+                status: 'timeout',
+                completionReason: 'max_iterations',
+            };
+        }, (result) => ({
+            inputTokens: result.totalTokens.input,
+            outputTokens: result.totalTokens.output,
+        }));
+    }
+}
+exports.HostProvider = HostProvider;

package/dist/core/providers/tool-utils.d.ts

@@ -0,0 +1,21 @@
+import { AITool } from '../ai-provider.interface';
+/**
+ * Formats tool definitions into a markdown string for system prompts.
+ * Used by providers that don't support native tool calling or need manual prompting.
+ */
+export declare function formatToolDefinitions(tools: AITool[]): string;
+/**
+ * Formats a tool execution result for inclusion in conversation history.
+ */
+export declare function formatToolOutput(toolName: string, output: any): string;
+/**
+ * Regex for extracting tool calls from markdown code blocks.
+ * Matches: ```json ... ``` and captures the content.
+ */
+export declare const TOOL_CALL_REGEX: RegExp;
+/**
+ * Extracts tool calls from a string containing markdown code blocks.
+ * Handles nested objects and malformed JSON gracefully.
+ */
+export declare function extractToolCalls(content: string): any[];
+//# sourceMappingURL=tool-utils.d.ts.map

package/dist/core/providers/tool-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-utils.d.ts","sourceRoot":"","sources":["../../../src/core/providers/tool-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAElD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAO7D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,MAAM,CAEtE;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,QAAgC,CAAC;AAE7D;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,EAAE,CAuBvD"}

package/dist/core/providers/tool-utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_CALL_REGEX = void 0;
+exports.formatToolDefinitions = formatToolDefinitions;
+exports.formatToolOutput = formatToolOutput;
+exports.extractToolCalls = extractToolCalls;
+/**
+ * Formats tool definitions into a markdown string for system prompts.
+ * Used by providers that don't support native tool calling or need manual prompting.
+ */
+function formatToolDefinitions(tools) {
+    let toolDefinitions = '';
+    for (const tool of tools) {
+        toolDefinitions += `### ${tool.name}\n${tool.description}\n`;
+        toolDefinitions += `Schema: ${JSON.stringify(tool.inputSchema)}\n\n`;
+    }
+    return toolDefinitions;
+}
+/**
+ * Formats a tool execution result for inclusion in conversation history.
+ */
+function formatToolOutput(toolName, output) {
+    return `Tool '${toolName}' output:\n${JSON.stringify(output, null, 2)}`;
+}
+/**
+ * Regex for extracting tool calls from markdown code blocks.
+ * Matches: ```json ... ``` and captures the content.
+ */
+exports.TOOL_CALL_REGEX = /```json\s*([\s\S]*?)\s*```/g;
+/**
+ * Extracts tool calls from a string containing markdown code blocks.
+ * Handles nested objects and malformed JSON gracefully.
+ */
+function extractToolCalls(content) {
+    const toolCalls = [];
+    const matches = [...content.matchAll(exports.TOOL_CALL_REGEX)];
+    for (const match of matches) {
+        try {
+            const jsonContent = match[1];
+            const parsed = JSON.parse(jsonContent);
+            if (Array.isArray(parsed)) {
+                for (const item of parsed) {
+                    if (item && typeof item === 'object' && item.tool) {
+                        toolCalls.push(item);
+                    }
+                }
+            }
+            else if (parsed && typeof parsed === 'object' && parsed.tool) {
+                toolCalls.push(parsed);
+            }
+        }
+        catch (e) {
+            // Ignore parse errors
+        }
+    }
+    return toolCalls;
+}

package/dist/interfaces/mcp.d.ts

@@ -39,6 +39,8 @@ export declare class MCPServer {
      * Register prompts capability with McpServer
      */
     private registerPrompts;
+    private configureHostProvider;
+    private handleSamplingRequest;
     private generateRequestId;
     start(): Promise<void>;
     private startStdioTransport;

package/dist/interfaces/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/interfaces/mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAkDtC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;CACxC;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,UAAU,CAAC,CAAkC;IACrD,OAAO,CAAC,aAAa,CAAC,CAAgC;IACtD,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,aAAa,CAAgB;gBAEzB,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe;IAsCjD;;OAEG;IACH,OAAO,CAAC,YAAY;IA2BpB;;OAEG;IACH,OAAO,CAAC,aAAa;IA6HrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqCvB,OAAO,CAAC,iBAAiB;IAInB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAkBd,mBAAmB;YAMnB,kBAAkB;YAmHlB,gBAAgB;IAexB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB3B,OAAO,IAAI,OAAO;CAGnB"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/interfaces/mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAkDtC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;CACxC;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,UAAU,CAAC,CAAkC;IACrD,OAAO,CAAC,aAAa,CAAC,CAAgC;IACtD,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,aAAa,CAAgB;gBAEzB,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe;IAyCjD;;OAEG;IACH,OAAO,CAAC,YAAY;IA8BpB;;OAEG;IACH,OAAO,CAAC,aAAa;IA6HrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqCvB,OAAO,CAAC,qBAAqB;YAgBf,qBAAqB;IAuBnC,OAAO,CAAC,iBAAiB;IAInB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAkBd,mBAAmB;YAMnB,kBAAkB;YAmHlB,gBAAgB;IAexB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB3B,OAAO,IAAI,OAAO;CAGnB"}

package/dist/interfaces/mcp.js

@@ -52,6 +52,8 @@ class MCPServer {
                 prompts: {},
             },
         });
+        // Configure HostProvider if active
+        this.configureHostProvider();
         this.logger.info('Initializing MCP Server', {
             name: config.name,
             version: config.version,
@@ -73,7 +75,10 @@ class MCPServer {
             return await (0, tracing_1.withToolTracing)(name, args, handler);
         };
         // Register traced handler with MCP server
-        this.server.tool(name, description, inputSchema, tracedHandler);
+        this.server.registerTool(name, {
+            description,
+            inputSchema
+        }, tracedHandler);
         // Register traced handler with REST registry
         this.restRegistry.registerTool({
             name,
@@ -164,6 +169,39 @@ class MCPServer {
             endpoints: ['prompts/list', 'prompts/get'],
         });
     }
+    configureHostProvider() {
+        // Configure HostProvider if active
+        // We use capability detection (duck typing) to avoid strict class dependency
+        // and handle potential class loading issues
+        const aiProvider = this.dotAI.ai;
+        if (typeof aiProvider.setSamplingHandler === 'function') {
+            this.logger.info('Configuring Host AI Provider with Sampling capability');
+            aiProvider.setSamplingHandler(this.handleSamplingRequest.bind(this));
+        }
+        else {
+            this.logger.info('Using configured AI Provider', {
+                type: this.dotAI.ai.getProviderType ? this.dotAI.ai.getProviderType() : 'unknown'
+            });
+        }
+    }
+    async handleSamplingRequest(messages, systemPrompt, options) {
+        try {
+            if (!this.server.server.createMessage) {
+                throw new Error('Server does not support createMessage (sampling)');
+            }
+            return await this.server.server.createMessage({
+                messages,
+                systemPrompt,
+                includeContext: 'none',
+                maxTokens: options?.maxTokens || 4096,
+                ...options
+            });
+        }
+        catch (error) {
+            this.logger.error('Sampling request failed', error);
+            throw error;
+        }
+    }
     generateRequestId() {
         return `mcp_${Date.now()}_${++this.requestIdCounter}`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vfarcic/dot-ai",
-  "version": "0.159.0",
+  "version": "0.161.0",
   "description": "AI-powered development productivity platform that enhances software development workflows through intelligent automation and AI-driven assistance",
   "mcpName": "io.github.vfarcic/dot-ai",
   "main": "dist/index.js",
@@ -17,6 +17,7 @@
     "test:integration:teardown": "./tests/integration/infrastructure/teardown-cluster.sh",
     "test:integration:server": "KUBECONFIG=./kubeconfig-test.yaml PORT=3456 DOT_AI_SESSION_DIR=./tmp/sessions TRANSPORT_TYPE=http QDRANT_URL=http://localhost:6335 QDRANT_CAPABILITIES_COLLECTION=capabilities-policies ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY OPENAI_API_KEY=$OPENAI_API_KEY node dist/mcp/server.js",
     "test:integration": "./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:unit": "vitest --config=vitest.unit.config.ts",
     "test:integration:watch": "vitest --config=vitest.integration.config.ts --test-timeout=1200000",
     "test:integration:sonnet": "AI_PROVIDER=anthropic DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
     "test:integration:opus": "AI_PROVIDER=anthropic_opus DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",

package/prompts/host-tools.md

@@ -0,0 +1,15 @@
+---
+name: host-tools
+description: System prompt for host tools execution loop
+category: core
+---
+## Available Tools
+
+You have access to the following tools. To use a tool, output a JSON block with the format:
+```json
+{ "tool": "tool_name", "arguments": { ... } }
+```
+
+{{TOOL_DEFINITIONS}}
+
+When you have gathered enough information, provide your final answer without any tool calls.