asktable-advisor 1.0.2__tar.gz → 1.0.4__tar.gz

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/.env.example

@@ -17,6 +17,11 @@ AGENT_MODEL=qwen3-max
 AGENT_TEMPERATURE=0.7
 AGENT_MAX_TOKENS=8192  # Maximum: 65536 for qwen3-max
 
+# Logging Configuration
+# Options: DEBUG, INFO, WARNING, ERROR, CRITICAL
+# Use WARNING or ERROR to reduce log output in production
+LOG_LEVEL=WARNING
+
 # MySQL Database Configuration
 MYSQL_HOST=
 MYSQL_PORT=

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asktable-advisor
-Version: 1.0.2
+Version: 1.0.4
 Summary: Conversational AI Agent for building AskTable demo scenarios
 Author-email: DataMini <contact@asktable.com>
 Maintainer-email: DataMini <contact@asktable.com>

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor/__main__.py

@@ -1,29 +1,39 @@
 """Command-line interface for AskTable Advisor."""
 
-import sys
 import logging
-from pathlib import Path
+import sys
 
 from rich.console import Console
-from rich.panel import Panel
 from rich.markdown import Markdown
+from rich.panel import Panel
 from rich.prompt import Prompt
 
-from .config import AdvisorSettings, get_settings
 from .agent.advisor import AdvisorAgent
+from .config import get_settings
 
 # Setup console
 console = Console()
 
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[
-        logging.FileHandler("asktable_advisor.log"),
-        logging.StreamHandler(sys.stderr),
-    ],
-)
+
+def setup_logging(log_level: str = "WARNING") -> None:
+    """
+    Setup logging configuration.
+
+    Args:
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    """
+    # Convert string to logging level
+    numeric_level = getattr(logging, log_level.upper(), logging.WARNING)
+
+    logging.basicConfig(
+        level=numeric_level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.FileHandler("asktable_advisor.log"),
+            logging.StreamHandler(sys.stderr),
+        ],
+        force=True,  # Override any existing configuration
+    )
 
 
 def print_welcome() -> None:
@@ -128,6 +138,9 @@ def main() -> None:
         # Load settings
         settings = get_settings()
 
+        # Setup logging with configured level
+        setup_logging(settings.log_level)
+
         # Print welcome
         print_welcome()
 

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor/__version__.py

@@ -1,4 +1,4 @@
 """Version information for asktable-advisor."""
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor/agent/advisor.py

@@ -9,6 +9,7 @@ from anthropic.types import Message, MessageParam
 from ..config import AdvisorSettings
 from ..asktable.client import AskTableClient
 from ..asktable.inspector import AskTableInspector
+from ..asktable.api_schema import get_api_schema
 from ..database.manager import DatabaseManager
 from ..database.schema_generator import SchemaGenerator
 from ..database.data_generator import DataGenerator
@@ -43,6 +44,7 @@ class AdvisorAgent:
             base_url=settings.asktable_api_base,
         )
         self.asktable_inspector = AskTableInspector(self.asktable_client)
+        self.api_schema = get_api_schema(settings.asktable_api_base)
 
         # Generators
         self.schema_generator = SchemaGenerator(self.llm_client)
@@ -199,6 +201,24 @@ class AdvisorAgent:
         elif tool_name == "create_permissions":
             return self._tool_create_permissions(tool_input)
 
+        elif tool_name == "ask_datasource":
+            return self._tool_ask_datasource(tool_input)
+
+        elif tool_name == "ask_bot":
+            return self._tool_ask_bot(tool_input)
+
+        elif tool_name == "list_available_datasources":
+            return self._tool_list_datasources(tool_input)
+
+        elif tool_name == "list_available_bots":
+            return self._tool_list_bots(tool_input)
+
+        elif tool_name == "search_asktable_api":
+            return self._tool_search_api(tool_input)
+
+        elif tool_name == "call_asktable_api":
+            return self._tool_call_api(tool_input)
+
         elif tool_name == "ask_user":
             return self._tool_ask_user(tool_input)
 
@@ -312,6 +332,79 @@ class AdvisorAgent:
             "roles": params.get("roles", []),
         }
 
+    def _tool_ask_datasource(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Ask a question to a datasource."""
+        datasource_id = params["datasource_id"]
+        question = params["question"]
+        max_rows = params.get("max_rows")
+
+        answer = self.asktable_client.ask_datasource(
+            datasource_id=datasource_id,
+            question=question,
+            max_rows=max_rows,
+        )
+
+        return answer
+
+    def _tool_ask_bot(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Ask a question to a bot."""
+        bot_id = params["bot_id"]
+        question = params["question"]
+        chat_id = params.get("chat_id")
+
+        message = self.asktable_client.ask_bot(
+            bot_id=bot_id,
+            question=question,
+            chat_id=chat_id,
+        )
+
+        return message
+
+    def _tool_list_datasources(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """List all available datasources."""
+        datasources = self.asktable_client.list_datasources()
+
+        return {
+            "datasources": datasources,
+            "count": len(datasources),
+        }
+
+    def _tool_list_bots(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """List all available bots."""
+        bots = self.asktable_client.list_bots()
+
+        return {
+            "bots": bots,
+            "count": len(bots),
+        }
+
+    def _tool_search_api(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Search for AskTable API endpoints."""
+        query = params["query"]
+        results = self.api_schema.search_endpoints(query)
+
+        return {
+            "query": query,
+            "results": results,
+            "count": len(results),
+        }
+
+    def _tool_call_api(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Call any AskTable API endpoint."""
+        method = params["method"]
+        path = params["path"]
+        query_params = params.get("params")
+        json_data = params.get("json_data")
+
+        result = self.asktable_client.call_api(
+            method=method,
+            path=path,
+            params=query_params,
+            json_data=json_data,
+        )
+
+        return result
+
     def _tool_ask_user(self, params: Dict[str, Any]) -> str:
         """Ask user a question (returns question to be displayed)."""
         # In CLI mode, this will be handled by the CLI layer

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor/agent/prompts.py

@@ -20,12 +20,36 @@ SYSTEM_PROMPT = """你是 AskTable Advisor，一个专业的 AskTable 场景构
 - 深入理解 AskTable 的核心概念：Datasource、Bot、Chat、Role、Policy
 - 熟悉 AskTable 的最佳实践和配置技巧
 - 能够优化 Bot 配置，提升用户体验
+- **能够使用 AskTable 回答用户的数据分析问题**
 
 ### 数据生成专家
 - 能够生成真实感、符合业务逻辑的虚拟数据
 - 确保数据之间的关联关系正确（外键约束、业务规则等）
 - 生成的数据具有多样性和代表性
 
+### 数据分析助手
+- **当用户询问数据相关问题时，可以使用 AskTable 来查询和分析数据**
+- 支持两种查询方式：
+  - **ask_datasource**：直接向数据源提问，快速获取数据
+  - **ask_bot**：通过 Bot 提问，获得更专业的分析和洞察
+- 能够解读查询结果，为用户提供清晰的答案
+
+### API 调用专家（新能力！）
+- **可以调用 AskTable 的任何 API**，不仅限于预定义的工具
+- 使用 **search_asktable_api** 搜索需要的 API 端点
+- 使用 **call_asktable_api** 调用找到的 API
+- 支持的功能包括：
+  - Canvas（画布）管理
+  - Report（报表）管理
+  - 高级权限配置
+  - 项目设置
+  - 以及所有 130+ 个 AskTable API 端点
+- **工作流程**：
+  1. 用户提出需求（如"创建一个 canvas"）
+  2. 使用 search_asktable_api 搜索相关 API
+  3. 使用 call_asktable_api 调用 API
+  4. 解读结果并反馈给用户
+
 ## 工作方式
 
 ### 1. 对话式交互
@@ -97,6 +121,20 @@ SYSTEM_PROMPT = """你是 AskTable Advisor，一个专业的 AskTable 场景构
 
 ## 处理用户请求的策略
 
+### 回答数据分析问题（新功能！）
+当用户询问与数据相关的问题时：
+1. **识别问题类型**：
+   - 简单数据查询（如"最近 7 天的订单量"）→ 使用 ask_datasource
+   - 需要深入分析（如"分析销售趋势并给出建议"）→ 使用 ask_bot
+2. **获取可用资源**：
+   - 调用 list_available_datasources 查看可用数据源
+   - 调用 list_available_bots 查看可用 Bot
+3. **执行查询**：
+   - 使用 ask_datasource 或 ask_bot 获取答案
+   - 解读结果并以清晰的方式呈现给用户
+4. **提示**：
+   - 如果没有合适的数据源或 Bot，可以建议用户先创建场景
+
 ### 创建新场景
 1. 识别场景类型（电商、教育、CRM 等）
 2. 询问关键信息：
@@ -118,6 +156,52 @@ SYSTEM_PROMPT = """你是 AskTable Advisor，一个专业的 AskTable 场景构
 3. 提出优化方案并征求确认
 4. 执行优化操作
 
+### 使用动态 API 调用（强大的新功能！）
+当用户需要使用 AskTable 的其他功能时（如 Canvas、Report、高级配置等）：
+
+1. **搜索 API**：
+   - 使用 search_asktable_api 搜索相关的 API
+   - 提供搜索关键词（如"canvas"、"report"、"role"）
+   - 查看返回的 API 端点列表和描述
+
+2. **调用 API**：
+   - 使用 call_asktable_api 调用找到的 API
+   - 指定 method（GET/POST/PUT/DELETE/PATCH）
+   - 指定 path（如 /v1/canvas）
+   - 提供必要的参数或请求体
+
+3. **常见场景示例**：
+   - **创建 Canvas**：
+     ```
+     search_asktable_api(query="canvas create")
+     call_asktable_api(method="POST", path="/v1/canvas", json_data={"name": "xxx", ...})
+     ```
+   - **创建 Report**：
+     ```
+     search_asktable_api(query="report")
+     call_asktable_api(method="POST", path="/v1/reports", json_data={...})
+     ```
+   - **列出资源**：
+     ```
+     call_asktable_api(method="GET", path="/v1/canvas")
+     ```
+
+4. **最佳实践**：
+   - 先搜索，再调用（确保使用正确的 API）
+   - 检查 API 的参数要求
+   - 向用户解释将要执行的操作
+   - 清晰地呈现 API 返回的结果
+
+5. **可用的资源类型**：
+   - bots（Bot 管理）
+   - chats（对话管理）
+   - datasources（数据源管理）
+   - canvas（画布 - 可视化分析）
+   - reports（报表）
+   - roles、policies（权限管理）
+   - single-turn（单轮查询）
+   - 以及更多...
+
 ## 重要提示
 
 1. **主动性**：不要被动等待，主动询问必要的信息

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor/agent/tools.py

@@ -282,6 +282,134 @@ def get_tools() -> List[Dict[str, Any]]:
                 "required": ["datasource_id", "roles"],
             },
         },
+        {
+            "name": "ask_datasource",
+            "description": (
+                "直接向 AskTable 数据源提问，获取数据查询结果。"
+                "适用于需要快速查询数据的场景。"
+                "可以用自然语言提问，AskTable 会自动生成 SQL 并返回结果。"
+            ),
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "datasource_id": {
+                        "type": "string",
+                        "description": "数据源 ID，可以先使用 inspect_asktable_project 获取",
+                    },
+                    "question": {
+                        "type": "string",
+                        "description": "自然语言问题，如'最近7天的销售额是多少？'",
+                    },
+                    "max_rows": {
+                        "type": "integer",
+                        "description": "最大返回行数，默认不限制",
+                    },
+                },
+                "required": ["datasource_id", "question"],
+            },
+        },
+        {
+            "name": "ask_bot",
+            "description": (
+                "通过 AskTable Bot 提问，获取智能数据分析结果。"
+                "Bot 具有业务知识和分析能力，可以提供更专业的回答。"
+                "适用于需要深入分析和洞察的场景。"
+            ),
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "bot_id": {
+                        "type": "string",
+                        "description": "Bot ID，可以先使用 inspect_asktable_project 获取",
+                    },
+                    "question": {
+                        "type": "string",
+                        "description": "自然语言问题",
+                    },
+                    "chat_id": {
+                        "type": "string",
+                        "description": "Chat ID（可选），如果要在已有对话中继续提问",
+                    },
+                },
+                "required": ["bot_id", "question"],
+            },
+        },
+        {
+            "name": "list_available_datasources",
+            "description": (
+                "列出当前项目中所有可用的数据源。"
+                "用于查看可以查询哪些数据源。"
+                "返回数据源的 ID、名称、描述等信息。"
+            ),
+            "input_schema": {
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        },
+        {
+            "name": "list_available_bots",
+            "description": (
+                "列出当前项目中所有可用的 Bot。"
+                "用于查看可以使用哪些 Bot 来回答问题。"
+                "返回 Bot 的 ID、名称、描述、能力等信息。"
+            ),
+            "input_schema": {
+                "type": "object",
+                "properties": {},
+                "required": [],
+            },
+        },
+        {
+            "name": "search_asktable_api",
+            "description": (
+                "搜索 AskTable API 端点。"
+                "当需要查找特定功能的 API 时使用此工具。"
+                "返回匹配的 API 端点列表，包括路径、方法和描述。"
+            ),
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "搜索关键词，如'canvas'、'report'、'message'等",
+                    },
+                },
+                "required": ["query"],
+            },
+        },
+        {
+            "name": "call_asktable_api",
+            "description": (
+                "调用任意 AskTable API 端点。"
+                "这是一个通用工具，可以调用 AskTable 的任何 API。"
+                "在调用前建议先使用 search_asktable_api 查找合适的 API。"
+                "支持 GET、POST、PUT、DELETE、PATCH 等方法。"
+            ),
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "method": {
+                        "type": "string",
+                        "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"],
+                        "description": "HTTP 方法",
+                    },
+                    "path": {
+                        "type": "string",
+                        "description": "API 路径，如'/v1/canvas'或'/v1/reports'",
+                    },
+                    "params": {
+                        "type": "object",
+                        "description": "查询参数（用于 GET 请求）",
+                    },
+                    "json_data": {
+                        "type": "object",
+                        "description": "请求体数据（用于 POST/PUT/PATCH 请求）",
+                    },
+                },
+                "required": ["method", "path"],
+            },
+        },
         {
             "name": "ask_user",
             "description": (

asktable_advisor-1.0.4/asktable_advisor/asktable/api_schema.py

@@ -0,0 +1,226 @@
+"""AskTable OpenAPI schema parser and documentation generator."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class AskTableAPISchema:
+    """
+    Parse and provide AskTable OpenAPI schema documentation.
+
+    This class fetches the OpenAPI specification from AskTable API
+    and generates simplified documentation for LLM consumption.
+    """
+
+    def __init__(self, api_base_url: str = "https://api.asktable.com"):
+        """
+        Initialize API schema parser.
+
+        Args:
+            api_base_url: AskTable API base URL
+        """
+        self.api_base_url = api_base_url
+        self.openapi_url = f"{api_base_url}/openapi.json"
+        self._spec: Optional[Dict[str, Any]] = None
+        self._cache_file = Path("/tmp/asktable_openapi_cache.json")
+
+    @property
+    def spec(self) -> Dict[str, Any]:
+        """Get OpenAPI specification (cached)."""
+        if self._spec is None:
+            self._spec = self._load_spec()
+        return self._spec
+
+    def _load_spec(self) -> Dict[str, Any]:
+        """Load OpenAPI spec from cache or fetch from API."""
+        # Try cache first
+        if self._cache_file.exists():
+            try:
+                with open(self._cache_file, 'r') as f:
+                    spec = json.load(f)
+                logger.info("Loaded OpenAPI spec from cache")
+                return spec
+            except Exception as e:
+                logger.warning(f"Failed to load cache: {e}")
+
+        # Fetch from API
+        try:
+            logger.info(f"Fetching OpenAPI spec from {self.openapi_url}")
+            response = httpx.get(self.openapi_url, timeout=30.0)
+            response.raise_for_status()
+            spec = response.json()
+
+            # Save to cache
+            try:
+                with open(self._cache_file, 'w') as f:
+                    json.dump(spec, f)
+                logger.info("Saved OpenAPI spec to cache")
+            except Exception as e:
+                logger.warning(f"Failed to save cache: {e}")
+
+            return spec
+        except Exception as e:
+            logger.error(f"Failed to fetch OpenAPI spec: {e}")
+            return {"paths": {}}
+
+    def get_api_categories(self) -> Dict[str, List[str]]:
+        """
+        Get API endpoints grouped by category.
+
+        Returns:
+            Dict mapping category name to list of endpoint paths
+        """
+        paths = self.spec.get('paths', {})
+        categories: Dict[str, List[str]] = {}
+
+        for path in paths.keys():
+            # Extract category from path (e.g., /v1/bots/{id} -> bots)
+            parts = path.strip('/').split('/')
+            if len(parts) > 1 and parts[0] == 'v1':
+                category = parts[1]
+            else:
+                category = 'other'
+
+            if category not in categories:
+                categories[category] = []
+            categories[category].append(path)
+
+        return categories
+
+    def get_endpoint_info(self, path: str, method: str) -> Optional[Dict[str, Any]]:
+        """
+        Get detailed information about an API endpoint.
+
+        Args:
+            path: API path (e.g., /v1/bots)
+            method: HTTP method (e.g., GET, POST)
+
+        Returns:
+            Endpoint information or None if not found
+        """
+        paths = self.spec.get('paths', {})
+        if path not in paths:
+            return None
+
+        method_lower = method.lower()
+        endpoint = paths[path].get(method_lower)
+        if not endpoint:
+            return None
+
+        return {
+            'path': path,
+            'method': method.upper(),
+            'summary': endpoint.get('summary', ''),
+            'description': endpoint.get('description', ''),
+            'parameters': endpoint.get('parameters', []),
+            'requestBody': endpoint.get('requestBody'),
+            'responses': endpoint.get('responses', {}),
+        }
+
+    def generate_api_documentation(self, max_endpoints: int = 50) -> str:
+        """
+        Generate simplified API documentation for LLM.
+
+        Args:
+            max_endpoints: Maximum number of endpoints to include
+
+        Returns:
+            Formatted API documentation string
+        """
+        categories = self.get_api_categories()
+        doc_lines = [
+            "# AskTable API 参考文档",
+            "",
+            f"API 版本: {self.spec.get('info', {}).get('version', 'unknown')}",
+            f"Base URL: {self.api_base_url}",
+            "",
+            "## API 分类",
+            "",
+        ]
+
+        # Priority categories (most commonly used)
+        priority_categories = [
+            'bots', 'chats', 'datasources', 'single-turn',
+            'canvas', 'reports', 'roles', 'policies'
+        ]
+
+        endpoint_count = 0
+        for category in priority_categories:
+            if category not in categories:
+                continue
+            if endpoint_count >= max_endpoints:
+                break
+
+            doc_lines.append(f"### {category}")
+            doc_lines.append("")
+
+            paths = self.spec.get('paths', {})
+            for path in categories[category][:5]:  # Limit per category
+                if endpoint_count >= max_endpoints:
+                    break
+
+                for method in ['get', 'post', 'put', 'delete', 'patch']:
+                    if method in paths.get(path, {}):
+                        endpoint = paths[path][method]
+                        summary = endpoint.get('summary', '')
+                        if summary:
+                            doc_lines.append(f"- `{method.upper()} {path}` - {summary}")
+                            endpoint_count += 1
+
+            doc_lines.append("")
+
+        return "\n".join(doc_lines)
+
+    def search_endpoints(self, query: str) -> List[Dict[str, Any]]:
+        """
+        Search for API endpoints by keyword.
+
+        Args:
+            query: Search query (e.g., "chat", "message", "datasource")
+
+        Returns:
+            List of matching endpoints with their info
+        """
+        query_lower = query.lower()
+        results = []
+
+        paths = self.spec.get('paths', {})
+        for path, methods in paths.items():
+            # Check if query matches path
+            if query_lower in path.lower():
+                for method, endpoint in methods.items():
+                    if method.upper() in ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']:
+                        results.append({
+                            'path': path,
+                            'method': method.upper(),
+                            'summary': endpoint.get('summary', ''),
+                            'score': 2 if query_lower in path.lower() else 1
+                        })
+            # Check if query matches summary/description
+            else:
+                for method, endpoint in methods.items():
+                    if method.upper() in ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']:
+                        summary = endpoint.get('summary', '').lower()
+                        description = endpoint.get('description', '').lower()
+                        if query_lower in summary or query_lower in description:
+                            results.append({
+                                'path': path,
+                                'method': method.upper(),
+                                'summary': endpoint.get('summary', ''),
+                                'score': 1
+                            })
+
+        # Sort by relevance score
+        results.sort(key=lambda x: x['score'], reverse=True)
+        return results[:10]  # Return top 10
+
+
+def get_api_schema(api_base_url: str = "https://api.asktable.com") -> AskTableAPISchema:
+    """Get or create AskTable API schema instance."""
+    return AskTableAPISchema(api_base_url)

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor/asktable/client.py

@@ -3,6 +3,7 @@
 import logging
 from typing import Any, Dict, List, Optional
 
+import httpx
 from asktable import Asktable
 
 logger = logging.getLogger(__name__)
@@ -269,3 +270,166 @@ class AskTableClient:
         except Exception as e:
             logger.error(f"Failed to create chat: {e}")
             raise
+
+    # Question & Answer operations
+    def ask_datasource(
+        self,
+        datasource_id: str,
+        question: str,
+        max_rows: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Ask a question directly to a datasource.
+
+        Args:
+            datasource_id: Target datasource ID
+            question: Natural language question
+            max_rows: Maximum rows to return (default: unlimited)
+
+        Returns:
+            Answer response with query results
+        """
+        try:
+            params = {
+                "datasource_id": datasource_id,
+                "question": question,
+            }
+            if max_rows is not None:
+                params["max_rows"] = max_rows
+
+            answer = self.client.answers.create(**params)
+
+            logger.info(f"Asked datasource {datasource_id}: {question[:50]}...")
+
+            if hasattr(answer, 'model_dump'):
+                return answer.model_dump()
+            elif hasattr(answer, 'dict'):
+                return answer.dict()
+            return answer
+        except Exception as e:
+            logger.error(f"Failed to ask datasource: {e}")
+            raise
+
+    def ask_bot(
+        self,
+        bot_id: str,
+        question: str,
+        chat_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Ask a question to a bot via chat.
+
+        Args:
+            bot_id: Target bot ID
+            question: Natural language question
+            chat_id: Existing chat ID (if None, creates a new chat)
+
+        Returns:
+            Message response with bot's answer
+        """
+        try:
+            # Create chat if not provided
+            if not chat_id:
+                chat = self.client.chats.create(
+                    bot_id=bot_id,
+                    name=f"Query: {question[:30]}...",
+                )
+                if hasattr(chat, 'id'):
+                    chat_id = chat.id
+                elif isinstance(chat, dict):
+                    chat_id = chat.get('id')
+                else:
+                    raise ValueError("Failed to get chat ID")
+
+            # Send message to chat
+            message = self.client.chats.messages.create(
+                chat_id=chat_id,
+                question=question,
+            )
+
+            logger.info(f"Asked bot {bot_id}: {question[:50]}...")
+
+            if hasattr(message, 'model_dump'):
+                return message.model_dump()
+            elif hasattr(message, 'dict'):
+                return message.dict()
+            return message
+        except Exception as e:
+            logger.error(f"Failed to ask bot: {e}")
+            raise
+
+    # Generic API operations
+    def call_api(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Call any AskTable API endpoint dynamically.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, PATCH)
+            path: API path (e.g., /v1/bots)
+            params: Query parameters
+            json_data: Request body (for POST/PUT/PATCH)
+
+        Returns:
+            API response as dict
+
+        Example:
+            # List all canvas
+            response = client.call_api('GET', '/v1/canvas')
+
+            # Create a report
+            response = client.call_api(
+                'POST',
+                '/v1/reports',
+                json_data={'name': 'My Report', 'bot_id': 'bot_xxx'}
+            )
+        """
+        try:
+            # Build full URL
+            if path.startswith('/'):
+                url = f"{self.base_url}{path}"
+            else:
+                url = f"{self.base_url}/{path}"
+
+            # Prepare headers
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            }
+
+            # Make request
+            method_upper = method.upper()
+            logger.info(f"Calling API: {method_upper} {path}")
+
+            with httpx.Client(timeout=60.0) as http_client:
+                response = http_client.request(
+                    method=method_upper,
+                    url=url,
+                    params=params,
+                    json=json_data,
+                    headers=headers,
+                )
+                response.raise_for_status()
+
+                # Try to parse JSON response
+                try:
+                    result = response.json()
+                except Exception:
+                    result = {"status": "success", "text": response.text}
+
+                logger.info(f"API call successful: {method_upper} {path}")
+                return result
+
+        except httpx.HTTPStatusError as e:
+            error_msg = f"HTTP {e.response.status_code}: {e.response.text}"
+            logger.error(f"API call failed: {error_msg}")
+            raise Exception(error_msg)
+        except Exception as e:
+            logger.error(f"API call failed: {e}")
+            raise
+

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor/config.py

@@ -45,6 +45,12 @@ class AdvisorSettings(BaseSettings):
         description="Maximum tokens for LLM responses",
     )
 
+    # Logging Configuration
+    log_level: str = Field(
+        default="WARNING",
+        description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    )
+
     # MySQL Database Configuration
     mysql_host: str = Field(..., description="MySQL host")
     mysql_port: int = Field(default=3306, description="MySQL port")

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asktable-advisor
-Version: 1.0.2
+Version: 1.0.4
 Summary: Conversational AI Agent for building AskTable demo scenarios
 Author-email: DataMini <contact@asktable.com>
 Maintainer-email: DataMini <contact@asktable.com>

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/asktable_advisor.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ asktable_advisor/agent/llm_client.py
 asktable_advisor/agent/prompts.py
 asktable_advisor/agent/tools.py
 asktable_advisor/asktable/__init__.py
+asktable_advisor/asktable/api_schema.py
 asktable_advisor/asktable/client.py
 asktable_advisor/asktable/inspector.py
 asktable_advisor/asktable/resources/__init__.py

{asktable_advisor-1.0.2 → asktable_advisor-1.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "asktable-advisor"
-version = "1.0.2"
+version = "1.0.4"
 description = "Conversational AI Agent for building AskTable demo scenarios"
 readme = "README.md"
 requires-python = ">=3.10"