spice-mcp 0.1.2__tar.gz → 0.1.4__tar.gz

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/.gitignore

@@ -21,3 +21,6 @@ bin/
 .github/
 .factory/
 debug_api.py
+
+# Local testing environment
+test_spice_mcp/

spice_mcp-0.1.4/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: spice-mcp
+Version: 0.1.4
+Summary: MCP server for Dune Analytics data access
+Author-email: Evan-Kim2028 <ekcopersonal@gmail.com>
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: fastmcp>=0.3.0
+Requires-Dist: mcp>=0.9.0
+Requires-Dist: polars>=1.35.1
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich-argparse>=1.5.2
+Requires-Dist: rich>=13.3.3
+Description-Content-Type: text/markdown
+
+# spice-mcp
+
+[![PyPI version](https://img.shields.io/pypi/v/spice-mcp.svg)](https://pypi.org/project/spice-mcp/)
+<a href="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp/badge" alt="Spice MCP server" />
+</a>
+
+An MCP server that provides AI agents with direct access to [Dune Analytics](https://dune.com/) data. Execute queries, discover schemas and tables, and manage saved queries—all through a clean, type-safe interface optimized for AI workflows.
+
+## Why spice-mcp?
+
+- **Agent-friendly**: Designed for AI agents using the Model Context Protocol (MCP)
+- **Efficient**: Polars-first pipeline keeps data lazy until needed, reducing memory usage
+- **Discovery**: Built-in tools to explore Dune's extensive blockchain datasets
+- **Type-safe**: Fully typed parameters and responses with FastMCP
+- **Reproducible**: Automatic query history logging and SQL artifact storage
+
+## Quick Start
+
+1. **Install**:
+   ```bash
+   uv pip install spice-mcp
+   ```
+
+2. **Set API key** (choose one method):
+   - **Option A**: Create a `.env` file in your project root:
+     ```bash
+     echo "DUNE_API_KEY=your-api-key-here" > .env
+     ```
+   - **Option B**: Export in your shell:
+     ```bash
+     export DUNE_API_KEY=your-api-key-here
+     ```
+
+3. **Use with Cursor IDE**:
+   Add to Cursor Settings → MCP Servers:
+   ```json
+   {
+     "name": "spice-mcp",
+     "command": "spice-mcp",
+     "env": {
+       "DUNE_API_KEY": "your-dune-api-key-here"
+     }
+   }
+   ```
+
+**Note**: Query history logging is enabled by default. Logs are saved to `logs/queries.jsonl` (or `~/.spice_mcp/logs/queries.jsonl` if not in a project directory). To customize paths, set `SPICE_QUERY_HISTORY` and `SPICE_ARTIFACT_ROOT` environment variables.
+
+## Core Tools
+
+| Tool | Description | Key Parameters |
+|------|-------------|----------------|
+| `dune_query` | Execute queries by ID, URL, or raw SQL | `query` (str), `parameters` (object), `limit` (int), `offset` (int), `format` (`preview\|raw\|metadata\|poll`), `refresh` (bool), `timeout_seconds` (float) |
+| `dune_query_info` | Get metadata for a saved query | `query` (str - ID or URL) |
+| `dune_discover` | Unified discovery across Dune API and Spellbook | `keyword` (str\|list), `schema` (str), `limit` (int), `source` (`dune\|spellbook\|both`), `include_columns` (bool) |
+| `dune_find_tables` | Search schemas and list tables | `keyword` (str), `schema` (str), `limit` (int) |
+| `dune_describe_table` | Get column metadata for a table | `schema` (str), `table` (str) |
+| `spellbook_find_models` | Search Spellbook dbt models | `keyword` (str\|list), `schema` (str), `limit` (int), `include_columns` (bool) |
+| `dune_health_check` | Verify API key and configuration | (no parameters) |
+| `dune_query_create` | Create a new saved query | `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_update` | Update an existing saved query | `query_id` (int), `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_fork` | Fork an existing saved query | `source_query_id` (int), `name` (str) |
+
+## Resources
+
+- `spice:history/tail/{n}` — View last N lines of query history (1-1000)
+- `spice:artifact/{sha}` — Retrieve stored SQL by SHA-256 hash
+
+## What is Dune?
+
+[Dune](https://dune.com/) is a crypto data platform providing curated blockchain datasets and a public API. It aggregates on-chain data from Ethereum, Solana, Polygon, and other chains into queryable SQL tables. See the [Dune Docs](https://dune.com/docs) for more information.
+
+## Installation
+
+**From PyPI** (recommended):
+```bash
+uv pip install spice-mcp
+```
+
+**From source**:
+```bash
+git clone https://github.com/Evan-Kim2028/spice-mcp.git
+cd spice-mcp
+uv sync
+uv pip install -e .
+```
+
+**Requirements**: Python 3.13+
+
+## Documentation
+
+- [Tool Reference](docs/tools.md) — Complete tool documentation with parameters
+- [Architecture](docs/architecture.md) — Code structure and design patterns
+- [Discovery Guide](docs/discovery.md) — How to explore Dune schemas and tables
+- [Dune API Guide](docs/dune_api.md) — Understanding Dune's data structure
+- [Configuration](docs/config.md) — Environment variables and settings
+
+## License
+
+See [LICENSE](LICENSE) file for details.

spice_mcp-0.1.4/README.md

@@ -0,0 +1,100 @@
+# spice-mcp
+
+[![PyPI version](https://img.shields.io/pypi/v/spice-mcp.svg)](https://pypi.org/project/spice-mcp/)
+<a href="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp/badge" alt="Spice MCP server" />
+</a>
+
+An MCP server that provides AI agents with direct access to [Dune Analytics](https://dune.com/) data. Execute queries, discover schemas and tables, and manage saved queries—all through a clean, type-safe interface optimized for AI workflows.
+
+## Why spice-mcp?
+
+- **Agent-friendly**: Designed for AI agents using the Model Context Protocol (MCP)
+- **Efficient**: Polars-first pipeline keeps data lazy until needed, reducing memory usage
+- **Discovery**: Built-in tools to explore Dune's extensive blockchain datasets
+- **Type-safe**: Fully typed parameters and responses with FastMCP
+- **Reproducible**: Automatic query history logging and SQL artifact storage
+
+## Quick Start
+
+1. **Install**:
+   ```bash
+   uv pip install spice-mcp
+   ```
+
+2. **Set API key** (choose one method):
+   - **Option A**: Create a `.env` file in your project root:
+     ```bash
+     echo "DUNE_API_KEY=your-api-key-here" > .env
+     ```
+   - **Option B**: Export in your shell:
+     ```bash
+     export DUNE_API_KEY=your-api-key-here
+     ```
+
+3. **Use with Cursor IDE**:
+   Add to Cursor Settings → MCP Servers:
+   ```json
+   {
+     "name": "spice-mcp",
+     "command": "spice-mcp",
+     "env": {
+       "DUNE_API_KEY": "your-dune-api-key-here"
+     }
+   }
+   ```
+
+**Note**: Query history logging is enabled by default. Logs are saved to `logs/queries.jsonl` (or `~/.spice_mcp/logs/queries.jsonl` if not in a project directory). To customize paths, set `SPICE_QUERY_HISTORY` and `SPICE_ARTIFACT_ROOT` environment variables.
+
+## Core Tools
+
+| Tool | Description | Key Parameters |
+|------|-------------|----------------|
+| `dune_query` | Execute queries by ID, URL, or raw SQL | `query` (str), `parameters` (object), `limit` (int), `offset` (int), `format` (`preview\|raw\|metadata\|poll`), `refresh` (bool), `timeout_seconds` (float) |
+| `dune_query_info` | Get metadata for a saved query | `query` (str - ID or URL) |
+| `dune_discover` | Unified discovery across Dune API and Spellbook | `keyword` (str\|list), `schema` (str), `limit` (int), `source` (`dune\|spellbook\|both`), `include_columns` (bool) |
+| `dune_find_tables` | Search schemas and list tables | `keyword` (str), `schema` (str), `limit` (int) |
+| `dune_describe_table` | Get column metadata for a table | `schema` (str), `table` (str) |
+| `spellbook_find_models` | Search Spellbook dbt models | `keyword` (str\|list), `schema` (str), `limit` (int), `include_columns` (bool) |
+| `dune_health_check` | Verify API key and configuration | (no parameters) |
+| `dune_query_create` | Create a new saved query | `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_update` | Update an existing saved query | `query_id` (int), `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_fork` | Fork an existing saved query | `source_query_id` (int), `name` (str) |
+
+## Resources
+
+- `spice:history/tail/{n}` — View last N lines of query history (1-1000)
+- `spice:artifact/{sha}` — Retrieve stored SQL by SHA-256 hash
+
+## What is Dune?
+
+[Dune](https://dune.com/) is a crypto data platform providing curated blockchain datasets and a public API. It aggregates on-chain data from Ethereum, Solana, Polygon, and other chains into queryable SQL tables. See the [Dune Docs](https://dune.com/docs) for more information.
+
+## Installation
+
+**From PyPI** (recommended):
+```bash
+uv pip install spice-mcp
+```
+
+**From source**:
+```bash
+git clone https://github.com/Evan-Kim2028/spice-mcp.git
+cd spice-mcp
+uv sync
+uv pip install -e .
+```
+
+**Requirements**: Python 3.13+
+
+## Documentation
+
+- [Tool Reference](docs/tools.md) — Complete tool documentation with parameters
+- [Architecture](docs/architecture.md) — Code structure and design patterns
+- [Discovery Guide](docs/discovery.md) — How to explore Dune schemas and tables
+- [Dune API Guide](docs/dune_api.md) — Understanding Dune's data structure
+- [Configuration](docs/config.md) — Environment variables and settings
+
+## License
+
+See [LICENSE](LICENSE) file for details.

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/docs/architecture.md

@@ -24,8 +24,8 @@
 ## Layers
 
 ### Core (`src/spice_mcp/core`)
-- `models.py` – dataclass representations for query requests, previews, metadata, schema descriptions, and Sui artefacts.
-- `ports.py` – protocols defining the boundaries (`QueryExecutor`, `CatalogExplorer`, `SuiInspector`).
+- `models.py` – dataclass representations for query requests, previews, metadata, schema descriptions.
+- `ports.py` – protocols defining the boundaries (`QueryExecutor`, `CatalogExplorer`).
 - `errors.py` – MCP-oriented error categorisation and envelope helpers (`error_response`).
 
 These modules contain zero infrastructure concerns; they define the shapes that higher layers orchestrate.
@@ -39,13 +39,12 @@ These modules contain zero infrastructure concerns; they define the shapes that
 ### Service Layer (`src/spice_mcp/service_layer`)
 - `query_service.py` – orchestrates `QueryExecutor` calls and shapes the dictionaries returned to MCP tools. Handles `performance` passthrough, metadata merging, and preview formatting.
 - `discovery_service.py` – thin façade around `CatalogExplorer`, returning friendlier lists for schema/table introspection.
-- `sui_service.py` – composes `QueryService` to deliver Sui-specific behaviours (events preview, package overview defaults).
 
 Services are pure Python and easily testable with stubbed ports (see `tests/tools/test_query_service.py`).
 
 ### MCP Integration (`src/spice_mcp/mcp`)
 - `server.py` – FastMCP stdio bridge. Lazily initialises configuration, adapters, services, tools, and resources. Provides resource URIs and tools while keeping stdout clean.
-- `tools/execute_query.py`, `tools/sui_package_overview.py` – thin glue calling into services, handling logging/audit trails, and shaping agent-friendly responses.
+- `tools/execute_query.py` – thin glue calling into services, handling logging/audit trails, and shaping agent-friendly responses.
 - Uses `QueryHistory` (`src/spice_mcp/logging/query_history.py`) for JSONL audit trails and SQL artefact storage.
 
 ### Observability (`src/spice_mcp/observability`)

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/docs/codex_cli.md

@@ -1,7 +1,7 @@
 Codex CLI MCP Setup (spice_mcp_beta)
 
 Goal
-- Register the spice-mcp server as an MCP provider named `spice_mcp_beta` for Codex CLI, so you can call tools like `dune_query` and use the Sui command URIs.
+- Register the spice-mcp server as an MCP provider named `spice_mcp_beta` for Codex CLI, so you can call tools like `dune_query`.
 
 Prereqs
 - Dune API key in your shell (e.g., export `DUNE_API_KEY=...`)
@@ -54,23 +54,17 @@ Verify configuration
 - `codex mcp list` should list `spice_mcp_beta` with the python command and no secrets in Env.
 
 Try some tools
-- Find Sui schemas
-  - `mcp__spice_mcp_beta__dune_find_tables {"keyword": "sui"}`
-- Describe `sui.transactions`
-  - `mcp__spice_mcp_beta__dune_describe_table {"schema": "sui", "table": "transactions"}`
+- Find schemas
+  - `mcp__spice_mcp_beta__dune_find_tables {"keyword": "dex"}`
+- Describe a table
+  - `mcp__spice_mcp_beta__dune_describe_table {"schema": "dex", "table": "trades"}`
 - Query preview (with metadata/pagination)
   - `mcp__spice_mcp_beta__dune_query {"query": "4388", "limit": 5}`
-  - `mcp__spice_mcp_beta__dune_query {"query": "SELECT * FROM sui.events LIMIT 5"}`
-MCP command URIs (resources)
-- You can read command-style resources for safe defaults (3-day windows, small LIMITs):
-  - Events preview: `spice:sui/events_preview/72/50/0xcaf6...,0x2c8d...`
-  - Package overview (cmd): `spice:sui/package_overview/72/30/0xcaf6...,0x2c8d...`
-  - Global preview (no package filter): `spice:sui/events_preview/72/50/_`
-  - See `docs/commands.md` for details. (Your client must support reading MCP resources.)
+  - `mcp__spice_mcp_beta__dune_query {"query": "SELECT * FROM dex.trades LIMIT 5"}`
 
 Notes & troubleshooting
 - Secret safety: Never store `DUNE_API_KEY` in Codex config; use `shell_environment_policy.inherit=["DUNE_API_KEY"]` or set it in your shell.
 - Missing key error: If you see `DUNE_API_KEY required`, export it in your shell and relaunch. The server also attempts to load `.env` from the project or home directory as a fallback.
 - FastMCP stdout: This server disables FastMCP banners/logging to keep stdio clean; if handshakes fail, ensure you used the exact `python -m spice_mcp.mcp.server` and PYTHONPATH as shown.
-- Heavy scans: Start with `format="metadata"` on `dune_query`, use `performance="large"`, and small `limit` with a recent time window; the Sui command URIs default to safe windows and limits.
+- Heavy scans: Start with `format="metadata"` on `dune_query`, use `performance="large"`, and small `limit` with a recent time window.
 - Tests/CI: set `SPICE_MCP_SKIP_DOTENV=1` to stop `_ensure_initialized` from reading local `.env` files when the key is intentionally absent.

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/docs/config.md

@@ -15,7 +15,7 @@ Optional
   - `SPICE_LOGGING_ENABLED`: true/false (default: true)
 - Timeouts
   - `SPICE_TIMEOUT_SECONDS`: default polling timeout (seconds)
-  - `SPICE_MAX_CONCURRENT_QUERIES`: max concurrent dune_query executions (default: 5)
+  - `SPICE_MAX_CONCURRENT_QUERIES`: reserved for future concurrency control (default: 5, not currently enforced)
 - Raw SQL
   - `SPICE_RAW_SQL_QUERY_ID`: ID of the template query used to execute raw SQL (default: 4060379). Health is reported by `dune_health_check` when set.
 

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/docs/development.md

@@ -4,7 +4,7 @@ This document summarizes local development workflows for spice-mcp.
 
 ## Tooling
 
-- Tests: `pytest` (+ `pytest-asyncio`, `responses`, `aioresponses`, `vcrpy`)
+- Tests: `pytest` (+ `responses`, `vcrpy`, `hypothesis`)
 - Lint/Format: `ruff` (lint + import sort + formatting)
 - Types: `mypy`
 
@@ -27,7 +27,7 @@ Enable live tests explicitly:
 - `tests/offline/`: pure unit tests; no network.
 - `tests/http_stubbed/`: HTTP boundary via `responses`.
 - `tests/tools/`: service + MCP tool unit tests.
-- `tests/mcp/`: FastMCP contract tests with stubbed services (preview/raw/metadata, Sui resources).
+- `tests/mcp/`: FastMCP contract tests with stubbed services (preview/raw/metadata).
 - `tests/fastmcp/`: registration/metadata smoke tests for FastMCP wiring.
 - `tests/style/`: static safety checks (lazyframe enforcement, etc.).
 - `tests/live/`: opt-in integrations; require `SPICE_TEST_LIVE=1` and `DUNE_API_KEY`.
@@ -36,7 +36,7 @@ Most unit/contract tests construct stub implementations of the ports in `src/spi
 
 ## Style
 
-- Follow Ruff + ruff-format defaults (88 cols, py39).
+- Follow Ruff + ruff-format defaults (88 cols, py313).
 - Prefer small, focused functions and explicit typing in `src/`.
 - Tests prioritize readability over strict typing.
 - Export `SPICE_MCP_SKIP_DOTENV=1` when running tests that expect the API key to be unset.

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/docs/discovery.md

@@ -17,10 +17,6 @@ Approach
   - Some deployments allow: information_schema.schemata/tables/columns
   - If blocked, use SHOW + probes
 
-Sui Examples
-- Find Sui schemas: SHOW SCHEMAS LIKE '%sui%'
-- Confirm core tables: SELECT * FROM sui.events/transactions/checkpoints/objects LIMIT 1
-- SHOW TABLES works on some Sui-related schemas (e.g., sui_base), but not all
 
 Helpers in this repo
 - `src/spice_mcp/service_layer/discovery_service.py` provides service wrappers around the Dune adapter:

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/docs/index.md

@@ -7,7 +7,7 @@ spice-mcp Documentation
 - Architecture Overview: `docs/architecture.md`
 - Dune API Overview: `docs/dune_api.md`
 - Catalog Discovery Guide: `docs/discovery.md`
-- Sui Packages (Deepbook) Workflow: `docs/sui_packages.md`
+
 - Codex CLI MCP Setup: `docs/codex_cli.md`
 - Development & Testing: `docs/development.md`
 

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/docs/tools.md

@@ -53,20 +53,7 @@ Logging & Artifacts
   - columns: [{ name, dune_type?, polars_dtype?, extra?, comment? }]
   - Errors follow the standard MCP envelope.
 
-4) sui_package_overview
-- Purpose: Preview Sui package activity (events, transactions, objects) over a time window; timeouts supported.
-- Input schema:
-  - packages: string[] (required)
-  - hours?: integer (default 72)
-  - timeout_seconds?: number (default 30)
-- Output fields (best-effort):
-  - ok: boolean
-  - events_count?, events_preview?, events_timeout?, events_error?
-  - transactions_count?, transactions_preview?, transactions_timeout?, transactions_error?
-  - objects_count?, objects_preview?, objects_timeout?, objects_error?
-  - On error: { ok: false, error: { … } }
-
- 5) dune_health_check
+4) dune_health_check
 - Purpose: Basic environment and logging readiness check.
 - Output fields: ok, api_key_present, status
 

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spice-mcp"
-version = "0.1.2"
+version = "0.1.4"
 description = "MCP server for Dune Analytics data access"
 authors = [
     { name = "Evan-Kim2028", email = "ekcopersonal@gmail.com" }

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/src/spice_mcp/adapters/dune/__init__.py

@@ -2,9 +2,11 @@
 
 This module provides a thin façade used by the new service layer while
 keeping the battle-tested logic that the original spice client offered.
+
+Only synchronous interfaces are exposed.
 """
 
 from . import urls  # re-export for callers needing low-level helpers
-from .extract import async_query, query  # noqa: F401
+from .extract import query  # noqa: F401
 
-__all__ = ["query", "async_query", "urls"]
+__all__ = ["query", "urls"]

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/src/spice_mcp/adapters/dune/cache.py

@@ -51,39 +51,7 @@ def load_from_cache(
         return None, execution
 
 
-async def async_load_from_cache(
-    execute_kwargs: _extract.ExecuteKwargs,
-    result_kwargs: _extract.RetrievalKwargs,
-    output_kwargs: _extract.OutputKwargs,
-) -> tuple[
-    pl.DataFrame | tuple[pl.DataFrame, Execution] | None, Execution | None
-]:
-    # get latest execution
-    execution = await _extract.async_get_latest_execution(execute_kwargs)
-    if execution is None:
-        return None, None
-
-    # build cache path
-    cache_path = _build_cache_path(
-        execution=execution,
-        execute_kwargs=execute_kwargs,
-        result_kwargs=result_kwargs,
-        cache_dir=output_kwargs['cache_dir'],
-    )
-
-    # load cache result
-    if os.path.exists(cache_path):
-        import polars as pl
-
-        if result_kwargs['verbose']:
-            print('loading dune query result from cache')
-        df = await pl.scan_parquet(cache_path).collect_async()
-        if output_kwargs['include_execution']:
-            return (df, execution), execution
-        else:
-            return df, execution
-    else:
-        return None, execution
+## Removed async cache loader; synchronous load_from_cache should be used exclusively.
 
 
 def save_to_cache(
@@ -113,7 +81,7 @@ def save_to_cache(
     # save to cache
     tmp_path = (
         cache_path + '_tmp_' + secrets.token_hex(8)
-    )  # add for if running in parallel
+    )  # add tmp suffix to avoid conflicts during writes
     df.write_parquet(tmp_path)
     shutil.move(tmp_path, cache_path)
 

{spice_mcp-0.1.2 → spice_mcp-0.1.4}/src/spice_mcp/adapters/dune/client.py

@@ -24,6 +24,10 @@ from ...polars_utils import collect_preview
 from ..http_client import HttpClient, HttpClientConfig
 from . import extract, urls
 
+# Use wrapper to avoid FastMCP detecting overloads in extract.query()
+# Note: We still import extract for _determine_input_type and other non-overloaded functions
+from .query_wrapper import execute_query as _execute_dune_query
+
 
 class DuneAdapter(QueryExecutor, CatalogExplorer):
     """Thin façade around the vendored extract module."""
@@ -47,7 +51,7 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
             q_rewritten = _maybe_rewrite_show_sql(q)
             if q_rewritten is not None:
                 q = q_rewritten
-        result = extract.query(
+        result = _execute_dune_query(
             query_or_execution=q,
             verbose=False,
             refresh=request.refresh,
@@ -123,9 +127,10 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
                     pass
 
             url = urls.get_query_results_url(query_id, parameters=params, csv=False)
+            from .user_agent import get_user_agent
             headers = {
                 "X-Dune-API-Key": self._api_key(),
-                "User-Agent": extract.get_user_agent(),
+                "User-Agent": get_user_agent(),
             }
             try:
                 resp = self._http.request("GET", url, headers=headers)
@@ -196,8 +201,8 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
     def _run_sql(self, sql: str, *, limit: int | None = None) -> pl.DataFrame:
         self._ensure_api_key()
         sql_eff = _maybe_rewrite_show_sql(sql) or sql
-        df = extract.query(
-            sql_eff,
+        df = _execute_dune_query(
+            query_or_execution=sql_eff,
             verbose=False,
             performance="medium",
             timeout_seconds=self.config.default_timeout_seconds,