sqlrite 0.1.23__tar.gz → 0.1.24__tar.gz

{sqlrite-0.1.23 → sqlrite-0.1.24}/Cargo.lock

@@ -3804,7 +3804,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-ask"
-version = "0.1.23"
+version = "0.1.24"
 dependencies = [
  "serde",
  "serde_json",
@@ -3815,7 +3815,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-desktop"
-version = "0.1.23"
+version = "0.1.24"
 dependencies = [
  "serde",
  "serde_json",
@@ -3827,7 +3827,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-engine"
-version = "0.1.23"
+version = "0.1.24"
 dependencies = [
  "clap",
  "env_logger",
@@ -3844,7 +3844,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-ffi"
-version = "0.1.23"
+version = "0.1.24"
 dependencies = [
  "cbindgen",
  "serde",
@@ -3854,7 +3854,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-nodejs"
-version = "0.1.23"
+version = "0.1.24"
 dependencies = [
  "napi",
  "napi-build",
@@ -3864,7 +3864,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-python"
-version = "0.1.23"
+version = "0.1.24"
 dependencies = [
  "pyo3",
  "sqlrite-engine",

{sqlrite-0.1.23 → sqlrite-0.1.24}/Cargo.toml

@@ -27,7 +27,7 @@ resolver = "3"
 # `package =` key so the import name stays `sqlrite` internally:
 #     sqlrite = { package = "sqlrite-engine", path = "…" }
 name = "sqlrite-engine"
-version = "0.1.23"
+version = "0.1.24"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"

{sqlrite-0.1.23 → sqlrite-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrite
-Version: 0.1.23
+Version: 0.1.24
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{sqlrite-0.1.23 → sqlrite-0.1.24}/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sqlrite-desktop-frontend",
   "private": true,
-  "version": "0.1.23",
+  "version": "0.1.24",
   "type": "module",
   "scripts": {
     "dev": "vite",

{sqlrite-0.1.23 → sqlrite-0.1.24}/docs/phase-7-plan.md

@@ -255,7 +255,7 @@ let rows = conn.execute(&resp.sql)?;
 - **✅ 7g.4 — Python SDK `conn.ask` / `ask_run` / `AskConfig`.** PyO3 wrappers over `sqlrite::ask::*`. New `Connection.ask(question, config=None)` returns an `AskResponse` (`.sql` / `.explanation` / `.usage` with cache-hit fields). `Connection.ask_run(question, config=None)` generates SQL then immediately executes via cursor — convenience for one-shot scripts/notebooks. `Connection.set_ask_config(cfg)` stashes a per-connection config. `AskConfig(api_key=..., model=..., max_tokens=..., cache_ttl=..., base_url=...)` constructor + `AskConfig.from_env()` static method. Three precedence layers: per-call > per-connection > env > defaults. `AskConfig.__repr__` and `AskResponse.__repr__` deliberately omit the API key — printing config in logs won't leak it. Empty SQL response (model declined) on `ask_run()` raises `SQLRiteError` with the model's explanation rather than executing the empty string. ~370 LOC of Rust binding + 415 LOC of pytest tests across 20 cases (config construction, env-var parsing, error paths, full happy-path through a localhost HTTP mock built on Python's stdlib `http.server`). README rewritten — three precedence layers explained, defaults enumerated, errors documented.
 - **✅ 7g.5 — Node.js SDK `db.ask` / `askRun` / `AskConfig`.** napi-rs wrappers over `sqlrite::ask::*`. `db.ask(question, config?)` returns `AskResponse { sql, explanation, usage }`. `db.askRun(question, config?)` generates SQL then immediately executes — returns rows directly (`Array<Object>`); throws on empty-SQL response (model declined) with the model's explanation, rather than executing the empty string. `db.setAskConfig(config)` stashes per-connection config (pass `null` to clear). `new AskConfig({apiKey, model, maxTokens, cacheTtl, baseUrl})` constructor + `AskConfig.fromEnv()` static. Three precedence layers: per-call > per-connection > env > defaults — same shape as the Python SDK, with idiomatic JS option-object instead of kwargs (camelCase: `maxTokens`/`cacheTtl`/`baseUrl`). `AskConfig.toString()` deliberately omits the API key value (shows `<set>` or `null`). Auto-generated TypeScript types in `index.d.ts` — `AskConfigOptions`, `AskResponse`, `AskUsage` interfaces. ~370 LOC of Rust binding + 380 LOC of node:test cases (30 total — 19 new for ask plus the original 11). Mock HTTP server runs in a `worker_thread` so napi-rs's blocking sync POST on the main thread doesn't deadlock the response — same insight as Python's GIL deadlock, different mitigation. README rewritten — three-layer precedence, defaults table, error behavior, what AskResponse carries, the no-key-in-toString guarantee, full TypeScript shapes.
 - **✅ 7g.6 — Go SDK `sqlrite.Ask` / `AskRun` / `AskConfig`.** cgo wrapper. New FFI function `sqlrite_ask(conn, question, config_json, *out)` accepts the AskConfig as a JSON string (smaller, more extensible C ABI than 6+ separate parameters) and returns `{sql, explanation, usage}` as JSON. Go side: `Ask(db *sql.DB, question, *AskConfig) (*AskResponse, error)` plus `AskContext(ctx, ...)` for context-aware connection-pool acquisition, `AskRun(db, question, *AskConfig) (*sql.Rows, error)` (and `AskRunContext`) that generates and executes in one call. `AskConfigFromEnv()` reads `SQLRITE_LLM_*`. `AskConfig.String()` deliberately omits the API key value (shows `<set>` or `<unset>`). Plumbs through `db.Conn(ctx).Raw()` to reach the underlying `*conn`'s opaque `*C.SqlriteConnection` handle. ~310 LOC of Go + ~200 LOC of Rust FFI extension + 380 LOC of Go tests (11 cases — config defaults / from-env / overrides / invalid-max-tokens, error paths for nil-db / missing-key / closed-db, full happy-path through `httptest.Server`, AskRun execution, empty-SQL declined-model, 4xx error surfacing). `httptest.Server` runs on a Go runtime goroutine, so unlike the Python (GIL) and Node (event-loop) SDKs there's no deadlock concern with synchronous cgo calls — Go test setup is the cleanest of the three. README rewritten — three-layer precedence, context-aware variants documented, errors enumerated, AskResponse type signatures shown.
-- **7g.7 — WASM SDK (~150 LOC, see Q9).** Either skipped, or implemented with a JS-side fetch hook (the WASM binary calls back into JS to make the HTTP request, since `reqwest`'s wasm32 story is messy and CORS/keys are a separate problem).
+- **✅ 7g.7 — WASM SDK `db.askPrompt()` / `db.askParse()` (Q9 split shape).** The WASM module does the schema-aware prompt construction in-page; the JS caller does the actual HTTP call (typically routed through their own backend that holds the API key). Two-step JS API: `db.askPrompt(question, options?)` returns Anthropic's `/v1/messages` request body shape; the caller POSTs that to their backend which forwards to Anthropic; `db.askParse(rawApiResponse)` parses the response back into `{ sql, explanation, usage }`. Browser never sees the API key, never POSTs to a third-party LLM endpoint, never deals with CORS. **Required structural refactor that 7g.7 unlocked:** feature-gated `ureq` on `sqlrite-ask` behind a default-on `http` feature; un-gated `sqlrite::ask::schema` so wasm-safe consumers get the schema dump without pulling in the HTTP transport; made `sqlrite_ask::parse_response` public for the WASM SDK to call. Net effect: `sqlrite-ask` builds clean for `wasm32-unknown-unknown` (verified via `wasm-pack build --target web`), and the WASM SDK reuses the canonical prompt rules + response parser without code duplication. ~250 LOC of WASM-side wrapper + the documented browser → backend → LLM provider → WASM example in `sdk/wasm/README.md` (Q9 doc requirement: complete worked example with a minimal Node/Express backend proxy showing where the API key lives).
 - **7g.8 — MCP server `ask` tool (~50 LOC).** Wires the existing tool framework from 7h to a single new tool that calls into `sqlrite-ask`.
 
 **Configuration:** the same config struct is accepted everywhere, with sensible env-var defaults:

{sqlrite-0.1.23 → sqlrite-0.1.24}/docs/roadmap.md

@@ -476,7 +476,7 @@ Approved sub-phases (Q1–Q10 resolved):
 - **✅ 7d — HNSW ANN index** — three PRs: 7d.1 (algorithm w/ recall@10 ≥ 0.95), 7d.2 (SQL integration + query optimizer), 7d.3 (persistence + DELETE/UPDATE rebuild). `CREATE INDEX … USING hnsw (col)`; fixed defaults `M=16, ef_construction=200, ef_search=50` (Q2). New `KIND_HNSW` cell tag.
 - **✅ 7e — JSON column type + path queries** — `JSON` data type stored as canonical text (validated via `serde_json::from_str` at INSERT/UPDATE time; SQLite-JSON1-style — Q3 scope correction since bincode was removed in Phase 3c). Functions: `json_extract` / `json_type` / `json_array_length` / `json_object_keys`. Path subset supports `$`, `.key`, `[N]`, chained. `json_object_keys` returns a JSON-array text rather than a table-valued result (no set-returning functions in the executor yet).
 - **7f — ~~Full-text search with BM25~~** — **deferred to Phase 8** (Q1).
-- **7g — `ask()` API across the product surface** — natural-language → SQL via Anthropic API (Q4), Anthropic-first then OpenAI + Ollama follow-ups. Foundational **✅ 7g.1** introduces a new `sqlrite-ask` crate (Q10 — separate crate, not a feature flag) — `ask_with_schema()` over `&str` inputs (Phase 7g.2 made it pure — see retrospective below), sync `ureq` POST to `/v1/messages`, schema-aware prompt with prompt-caching on the schema dump (Sonnet 4.6 default; configurable). **✅ 7g.2** wires the REPL's `.ask` meta-command (`MetaCommand::Ask(String)` + confirm-and-run UX) and adds the `sqlrite::ask` module on the engine side (gated under a new `ask` feature) carrying `ConnectionAskExt` + the schema introspection helper. **✅ 7g.3** adds the desktop "Ask…" composer (slide-in panel above the editor; Tauri command runs the LLM call in the Rust backend so the API key stays out of the webview). **✅ 7g.4** ships the Python SDK surface — `conn.ask(question, config=None)` returns an `AskResponse(.sql, .explanation, .usage)`; `conn.ask_run()` adds the one-shot generate-and-execute convenience; `AskConfig` carries the three-layer precedence (per-call > per-connection > env > defaults). **✅ 7g.5** ships the Node.js SDK surface — `db.ask(question, config?)`, `db.askRun(question, config?)`, `db.setAskConfig(cfg)`, `new AskConfig({apiKey, model, maxTokens, cacheTtl, baseUrl})` + `AskConfig.fromEnv()`. Same three-layer precedence; idiomatic JS camelCase option-object. **✅ 7g.6** ships the Go SDK surface via cgo — `sqlrite.Ask(db, q, *AskConfig)` / `AskRun(...)` plus `AskContext`/`AskRunContext` for context-aware variants. The FFI grew one new C function (`sqlrite_ask`) that takes the config as a JSON string and returns the response as JSON — smaller, more extensible ABI than plumbing 6+ struct fields across cgo. Per-product adapters in 7g.7-7g.8 cover WASM (JS-callback shape per Q9) and the MCP `ask` tool — and fold in the SDK README catch-up for VECTOR / JSON / HNSW capabilities along the way.
+- **7g — `ask()` API across the product surface** — natural-language → SQL via Anthropic API (Q4), Anthropic-first then OpenAI + Ollama follow-ups. Foundational **✅ 7g.1** introduces a new `sqlrite-ask` crate (Q10 — separate crate, not a feature flag) — `ask_with_schema()` over `&str` inputs (Phase 7g.2 made it pure — see retrospective below), sync `ureq` POST to `/v1/messages`, schema-aware prompt with prompt-caching on the schema dump (Sonnet 4.6 default; configurable). **✅ 7g.2** wires the REPL's `.ask` meta-command (`MetaCommand::Ask(String)` + confirm-and-run UX) and adds the `sqlrite::ask` module on the engine side (gated under a new `ask` feature) carrying `ConnectionAskExt` + the schema introspection helper. **✅ 7g.3** adds the desktop "Ask…" composer (slide-in panel above the editor; Tauri command runs the LLM call in the Rust backend so the API key stays out of the webview). **✅ 7g.4** ships the Python SDK surface — `conn.ask(question, config=None)` returns an `AskResponse(.sql, .explanation, .usage)`; `conn.ask_run()` adds the one-shot generate-and-execute convenience; `AskConfig` carries the three-layer precedence (per-call > per-connection > env > defaults). **✅ 7g.5** ships the Node.js SDK surface — `db.ask(question, config?)`, `db.askRun(question, config?)`, `db.setAskConfig(cfg)`, `new AskConfig({apiKey, model, maxTokens, cacheTtl, baseUrl})` + `AskConfig.fromEnv()`. Same three-layer precedence; idiomatic JS camelCase option-object. **✅ 7g.6** ships the Go SDK surface via cgo — `sqlrite.Ask(db, q, *AskConfig)` / `AskRun(...)` plus `AskContext`/`AskRunContext` for context-aware variants. The FFI grew one new C function (`sqlrite_ask`) that takes the config as a JSON string and returns the response as JSON — smaller, more extensible ABI than plumbing 6+ struct fields across cgo. **✅ 7g.7** ships the WASM SDK with the JS-callback shape per Q9 — `db.askPrompt(q, opts?)` returns the LLM-API request body, JS caller routes through their own backend, `db.askParse(rawResponse)` returns `{sql, explanation, usage}`. Required structurally: `sqlrite-ask` got an `http` feature flag (default-on, off for wasm); engine's `sqlrite::ask::schema` un-gated so wasm-safe consumers can introspect schemas without the HTTP transport; `sqlrite_ask::parse_response` made public. The remaining 7g.8 covers the MCP `ask` tool — folded in alongside the SDK README catch-up for VECTOR / JSON / HNSW capabilities.
 - **7h — MCP server adapter** — new `sqlrite-mcp` binary, hand-rolled JSON-RPC + tool framework (Q5).
 
 Total scope budget: ~3-4 kLOC of new Rust across the wave. Each sub-phase ships as its own PR + release wave through the Phase 6 pipeline. The Phase 7 wave will likely close out **v0.2.0** (first minor bump after the 0.1.x Phase 6 cycle). Two new product lines added to lockstep versioning: `sqlrite-ask` and `sqlrite-mcp`.

{sqlrite-0.1.23 → sqlrite-0.1.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlrite"
-version = "0.1.23"
+version = "0.1.24"
 description = "Python bindings for SQLRite — a small, embeddable SQLite clone written in Rust."
 authors = [{ name = "Joao Henrique Machado Silva", email = "joaoh82@gmail.com" }]
 license = { text = "MIT" }

{sqlrite-0.1.23 → sqlrite-0.1.24}/sdk/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlrite-python"
-version = "0.1.23"
+version = "0.1.24"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"

{sqlrite-0.1.23 → sqlrite-0.1.24}/sqlrite-ask/Cargo.toml

@@ -10,7 +10,7 @@
 # Published to crates.io as `sqlrite-ask`. Joins the lockstep release
 # wave (`sqlrite-ask-vX.Y.Z` tag) — see `docs/release-plan.md`.
 name = "sqlrite-ask"
-version = "0.1.23"
+version = "0.1.24"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"
@@ -48,13 +48,34 @@ serde_json = "1"
 # exactly one POST to api.anthropic.com, so the sync surface is a
 # perfect fit. Rolling our own JSON types over ureq is ~120 LOC
 # vs. ~400 LOC + tokio + reqwest::blocking via an SDK.
-ureq = { version = "2", features = ["json", "tls"] }
+#
+# **Optional behind the `http` feature** (default-on) as of Phase
+# 7g.7. The WASM SDK pulls this crate in with `default-features =
+# false` to use just the prompt construction + response parsing —
+# ureq's sync HTTP + rustls don't compile to wasm32. WASM ships its
+# own `db.askPrompt()` / `db.askParse()` shape per Q9, where the
+# browser hands the prompt to the caller's JS HTTP function and
+# parses the result back through this crate.
+ureq = { version = "2", features = ["json", "tls"], optional = true }
 
 # Typed errors. (Same crate the engine uses, so consumers that
 # enable the engine's `ask` feature can layer their own thiserror
 # wrapper without version skew.)
 thiserror = "2"
 
+[features]
+# Default is full HTTP-capable build — the engine's `ask` feature
+# (and the Python / Node / Go SDKs) all go through `ask_with_schema`,
+# which calls into the AnthropicProvider. Disabling `http` keeps
+# only the wasm-safe parts: prompt construction (`build_system`,
+# system rules), response parsing (`parse_response`), config types
+# (`AskConfig`, `AskResponse`, `AskUsage`, `AskError`), and the
+# generic `ask_with_schema_and_provider<P>` entry that takes a
+# caller-supplied provider. The WASM SDK is the only consumer that
+# turns this off today.
+default = ["http"]
+http = ["dep:ureq"]
+
 [dev-dependencies]
 # Throwaway tiny localhost HTTP server for the integration test
 # that exercises the real ureq path. Avoids hitting api.anthropic.com

{sqlrite-0.1.23 → sqlrite-0.1.24}/sqlrite-ask/src/lib.rs

@@ -73,9 +73,15 @@
 
 use std::env;
 
-mod prompt;
-mod provider;
-
+// `prompt` and parts of `provider` are wasm-safe (pure serde +
+// trait definitions); `provider::anthropic` is HTTP-only and lives
+// behind the `http` feature flag. Phase 7g.7 made these modules
+// `pub` so the WASM SDK can reuse `build_system` / `parse_response`
+// / `Usage` without duplicating them.
+pub mod prompt;
+pub mod provider;
+
+#[cfg(feature = "http")]
 pub use provider::anthropic::AnthropicProvider;
 pub use provider::{Provider, Request, Response, Usage};
 
@@ -275,6 +281,13 @@ pub enum AskError {
 ///
 /// The library does **not** execute the returned SQL — that's the
 /// caller's call. See module docs for rationale.
+///
+/// **Feature-gated under `http`** (default-on) — wraps the built-in
+/// `AnthropicProvider`, which uses ureq and isn't wasm-safe. WASM
+/// callers should use [`ask_with_schema_and_provider`] with a
+/// caller-supplied provider, or skip this crate entirely and use
+/// the WASM SDK's `db.askPrompt()` / `db.askParse()` shape (Q9).
+#[cfg(feature = "http")]
 pub fn ask_with_schema(
     schema_dump: &str,
     question: &str,
@@ -328,7 +341,12 @@ pub fn ask_with_schema_and_provider<P: Provider>(
 /// because real LLM output drifts even with strict instructions. The
 /// fence/prose tolerance matches what real callers do (better-sqlite3,
 /// rusqlite, etc.) when interfacing with model output.
-fn parse_response(raw: &str, usage: Usage) -> Result<AskResponse, AskError> {
+///
+/// **Public as of Phase 7g.7** so the WASM SDK can call this on the
+/// model-text portion of an LLM API response that JS retrieved (per
+/// Q9 the WASM module never makes the HTTP call itself; the JS
+/// caller hands the raw response back through `db.askParse()`).
+pub fn parse_response(raw: &str, usage: Usage) -> Result<AskResponse, AskError> {
     // 1. Strip markdown fences if the model wrapped its JSON.
     let trimmed = raw.trim();
     let body = strip_markdown_fence(trimmed).unwrap_or(trimmed);

{sqlrite-0.1.23 → sqlrite-0.1.24}/sqlrite-ask/src/provider/mod.rs

@@ -14,6 +14,12 @@
 use crate::AskError;
 use crate::prompt::{SystemBlock, UserMessage};
 
+// Anthropic adapter is HTTP-based (sync ureq POST). The `http`
+// feature gates the whole module so wasm32 builds — which can't
+// link ureq + rustls — skip it cleanly. The WASM SDK uses Q9's
+// JS-callback shape (caller does the HTTP from JS) and never
+// instantiates this provider.
+#[cfg(feature = "http")]
 pub mod anthropic;
 
 #[cfg(test)]

{sqlrite-0.1.23 → sqlrite-0.1.24}/src/ask/mod.rs

@@ -38,19 +38,28 @@
 //!   for callers who don't want to bring the trait into scope, or
 //!   who hold a `&Database` directly (the REPL binary does this).
 
+// Schema dump is always available (no sqlrite-ask dep). The
+// `ConnectionAskExt` trait + free helper functions below are gated
+// under the engine's `ask` feature because they pull in `sqlrite-ask`
+// (HTTP transport).
+pub mod schema;
+
+#[cfg(feature = "ask")]
 use sqlrite_ask::{ask_with_schema, ask_with_schema_and_provider};
 
+#[cfg(feature = "ask")]
 use crate::Connection;
+#[cfg(feature = "ask")]
 use crate::sql::db::database::Database;
 
-pub mod schema;
-
 // Re-export the public surface from sqlrite-ask. Lets callers reach
 // these without listing `sqlrite-ask` as a direct dep — convenient
 // for the Tauri desktop app, the SDK adapters, and any Rust embedder
 // who already pulls the engine in. They can keep saying
 // `use sqlrite::ask::AskConfig` instead of dragging the second crate
-// in just for one type.
+// in just for one type. Gated under `ask` because that's the feature
+// that pulls `sqlrite-ask` into the dep graph in the first place.
+#[cfg(feature = "ask")]
 pub use sqlrite_ask::{
     AnthropicProvider, AskConfig, AskError, AskResponse, CacheTtl, Provider, ProviderKind, Request,
     Response, Usage,
@@ -60,6 +69,10 @@ pub use sqlrite_ask::{
 /// [`crate::Connection`]. Bring it into scope with
 /// `use sqlrite::ConnectionAskExt;` (the engine re-exports it at
 /// the crate root).
+///
+/// Gated under the `ask` feature — pulls in `sqlrite-ask` and its
+/// HTTP transport. WASM and other lean builds skip this entirely.
+#[cfg(feature = "ask")]
 pub trait ConnectionAskExt {
     /// Generate SQL from a natural-language question.
     ///
@@ -80,6 +93,7 @@ pub trait ConnectionAskExt {
     fn ask(&self, question: &str, config: &AskConfig) -> Result<AskResponse, AskError>;
 }
 
+#[cfg(feature = "ask")]
 impl ConnectionAskExt for Connection {
     fn ask(&self, question: &str, config: &AskConfig) -> Result<AskResponse, AskError> {
         ask(self, question, config)
@@ -88,6 +102,7 @@ impl ConnectionAskExt for Connection {
 
 /// Free-function form of [`ConnectionAskExt::ask`]. Equivalent —
 /// pick whichever shape reads better at the call site.
+#[cfg(feature = "ask")]
 pub fn ask(conn: &Connection, question: &str, config: &AskConfig) -> Result<AskResponse, AskError> {
     ask_with_database(conn.database(), question, config)
 }
@@ -96,6 +111,7 @@ pub fn ask(conn: &Connection, question: &str, config: &AskConfig) -> Result<AskR
 ///
 /// Used by the REPL binary's `.ask` meta-command, which holds a
 /// `&mut Database` rather than a `&Connection`.
+#[cfg(feature = "ask")]
 pub fn ask_with_database(
     db: &Database,
     question: &str,
@@ -108,6 +124,7 @@ pub fn ask_with_database(
 /// Lower-level entry — same flow as [`ask`] but you supply the
 /// provider. For test harnesses + advanced callers driving custom
 /// backends.
+#[cfg(feature = "ask")]
 pub fn ask_with_provider<P: Provider>(
     conn: &Connection,
     question: &str,
@@ -119,6 +136,7 @@ pub fn ask_with_provider<P: Provider>(
 
 /// Lower-level entry taking `&Database` and a provider. Canonical
 /// inner function — the others reduce to this one.
+#[cfg(feature = "ask")]
 pub fn ask_with_database_and_provider<P: Provider>(
     db: &Database,
     question: &str,

{sqlrite-0.1.23 → sqlrite-0.1.24}/src/lib.rs

@@ -50,7 +50,14 @@
 #[macro_use]
 extern crate prettytable;
 
-#[cfg(feature = "ask")]
+// `sqlrite::ask` is always available — its `schema` submodule (the
+// CREATE TABLE dump used to ground the LLM's prompt) is pure-engine
+// and useful even for builds that don't enable the `ask` feature.
+// The `ConnectionAskExt` trait + `ask` / `ask_with_database`
+// helpers inside the module are gated under the feature, since
+// they pull in `sqlrite-ask`. The WASM SDK uses
+// `sqlrite::ask::schema::dump_schema_for_database` to introspect a
+// browser-side `Connection` without needing the HTTP transport.
 pub mod ask;
 pub mod connection;
 pub mod error;