@kaleidorg/mind 0.4.0 → 0.5.1

package/src/knowledge/btc-map.test.ts

@@ -1,12 +1,10 @@
 import { describe, expect, it } from 'vitest';
 import {
   createBtcMapToolSource,
-  BTC_MAP_SAMPLE,
   type BtcMapFetch,
   type LocationProvider,
   type BtcMapMerchant,
 } from './btc-map.js';
-import type { Merchant } from './merchants.js';
 
 const exec = async (
   src: ReturnType<typeof createBtcMapToolSource>,
@@ -15,13 +13,13 @@ const exec = async (
 ): Promise<any> => src.execute(name, args);
 
 describe('createBtcMapToolSource — tool surface', () => {
-  it('exposes find_merchant_locations and get_merchant_info', () => {
+  it('exposes ONLY find_merchant_locations (no get_merchant_info, no legacy name)', () => {
     const src = createBtcMapToolSource();
     const names = src.listTools().map((t) => t.name);
-    expect(names).toEqual(['find_merchant_locations', 'get_merchant_info']);
+    expect(names).toEqual(['find_merchant_locations']);
     expect(src.has('find_merchant_locations')).toBe(true);
-    expect(src.has('get_merchant_info')).toBe(true);
-    expect(src.has('find_merchants')).toBe(false); // legacy name is gone
+    expect(src.has('get_merchant_info')).toBe(false);
+    expect(src.has('find_merchants')).toBe(false);
   });
 
   it('throws on unknown tool', async () => {
@@ -30,51 +28,52 @@ describe('createBtcMapToolSource — tool surface', () => {
   });
 });
 
-describe('find_merchant_locations — offline fallback', () => {
-  it('returns offline rows when no location and no fetch are injected', async () => {
+describe('find_merchant_locations — no offline fallback', () => {
+  it('returns a clean error when no fetch adapter is injected', async () => {
     const src = createBtcMapToolSource();
     const r = await exec(src, 'find_merchant_locations', {});
-    expect(r.success).toBe(true);
-    expect(r.source).toBe('offline');
-    expect(r.precise_location).toBe(false);
-    expect(r.merchants.length).toBeGreaterThan(0);
-    expect(r.merchants.length).toBeLessThanOrEqual(10); // default limit
-  });
-
-  it('honours category filter on offline data', async () => {
-    const src = createBtcMapToolSource();
-    const r = await exec(src, 'find_merchant_locations', { category: 'bar' });
-    expect(r.merchants.every((m: any) => m.category === 'bar')).toBe(true);
-    // Sample has at least one bar (PubKey).
-    expect(r.merchants.length).toBeGreaterThan(0);
+    expect(r.success).toBe(false);
+    expect(typeof r.error).toBe('string');
+    expect(r.error).toMatch(/fetch adapter|unavailable/i);
+    expect(r.merchants).toBeUndefined();
   });
 
-  it('honours query filter on offline data', async () => {
-    const src = createBtcMapToolSource();
-    const r = await exec(src, 'find_merchant_locations', { query: 'PubKey' });
-    expect(r.merchants.some((m: any) => m.name === 'PubKey')).toBe(true);
+  it('returns a clean error when location cannot be resolved', async () => {
+    // Fetch is wired, but the location provider has no GPS and no geocoder.
+    const noLocation: LocationProvider = { getCurrent: async () => null };
+    const src = createBtcMapToolSource({
+      location: noLocation,
+      fetch: async () => [],
+    });
+    const r = await exec(src, 'find_merchant_locations', {});
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/location/i);
   });
 
-  it('clamps limit to 1–20 with a default of 10', async () => {
-    const src = createBtcMapToolSource();
-    const big = await exec(src, 'find_merchant_locations', { limit: 9999 });
-    expect(big.merchants.length).toBeLessThanOrEqual(20);
-    const tiny = await exec(src, 'find_merchant_locations', { limit: -5 });
-    expect(tiny.merchants.length).toBeGreaterThanOrEqual(1); // clamped to ≥1
+  it('surfaces a fetch failure as a clean error (no fake fallback)', async () => {
+    const src = createBtcMapToolSource({
+      location: { getCurrent: async () => ({ lat: 46.0, lng: 8.95, precise: true }) },
+      fetch: async () => { throw new Error('btcmap is down'); },
+    });
+    const r = await exec(src, 'find_merchant_locations', {});
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/btcmap is down/);
+    expect(r.merchants).toBeUndefined();
   });
 
-  it('caller can override the offline dataset', async () => {
-    const custom: Merchant[] = [
-      { id: 'only', name: 'Only Café', category: 'cafe', acceptedAssets: ['lightning'] },
-    ];
-    const src = createBtcMapToolSource({ offlineMerchants: custom });
-    const r = await exec(src, 'find_merchant_locations', {});
-    expect(r.merchants).toHaveLength(1);
-    expect(r.merchants[0].name).toBe('Only Café');
+  it('errors with the bad address when geocoding fails (no near_me fallback)', async () => {
+    const location: LocationProvider = {
+      getCurrent: async () => null,
+      geocode: async () => null,
+    };
+    const src = createBtcMapToolSource({ location, fetch: async () => [] });
+    const r = await exec(src, 'find_merchant_locations', { near_address: 'Nowhereistan' });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/Nowhereistan/);
   });
 });
 
-describe('find_merchant_locations — live path (host-injected fetch)', () => {
+describe('find_merchant_locations — live path', () => {
   const point = { lat: 46.0, lng: 8.95 };
   const locationOnly: LocationProvider = {
     getCurrent: async () => ({ ...point, label: 'Lugano', precise: true }),
@@ -91,6 +90,7 @@ describe('find_merchant_locations — live path (host-injected fetch)', () => {
     };
     const src = createBtcMapToolSource({ location: locationOnly, fetch: fetchImpl });
     const r = await exec(src, 'find_merchant_locations', { query: 'café', radius_km: 3 });
+    expect(r.success).toBe(true);
     expect(r.source).toBe('btcmap');
     expect(r.precise_location).toBe(true);
     expect(r.merchants[0].name).toBe('Live Café');
@@ -119,70 +119,27 @@ describe('find_merchant_locations — live path (host-injected fetch)', () => {
     ];
     const src = createBtcMapToolSource({ location, fetch: fetchImpl });
     const r = await exec(src, 'find_merchant_locations', { near_address: 'Lisbon' });
+    expect(r.success).toBe(true);
     expect(seen).toEqual(['Lisbon']);
     expect(r.merchants[0].lat).toBeCloseTo(geocoded.lat);
     expect(r.merchants[0].lng).toBeCloseTo(geocoded.lng);
     expect(r.precise_location).toBe(false); // came from geocode, not GPS
   });
 
-  it('falls back to offline when live fetch throws', async () => {
-    const src = createBtcMapToolSource({
-      location: locationOnly,
-      fetch: async () => { throw new Error('btcmap is down'); },
-    });
-    const r = await exec(src, 'find_merchant_locations', {});
-    expect(r.source).toBe('offline');
-    expect(r.merchants.length).toBeGreaterThan(0);
-  });
-
-  it('falls back to offline when location resolves but fetch is missing', async () => {
-    const src = createBtcMapToolSource({ location: locationOnly });
-    const r = await exec(src, 'find_merchant_locations', {});
-    expect(r.source).toBe('offline'); // no fetch injected → no live path
-  });
-});
-
-describe('get_merchant_info', () => {
-  it('finds a merchant by id', async () => {
-    const src = createBtcMapToolSource();
-    const r = await exec(src, 'get_merchant_info', { merchant_id: 'nyc-pubkey' });
-    expect(r.success).toBe(true);
-    expect(r.merchant.name).toBe('PubKey');
-    expect(r.merchant.accepts_lightning).toBe(true);
-  });
-
-  it('finds a merchant by exact name', async () => {
-    const src = createBtcMapToolSource();
-    const r = await exec(src, 'get_merchant_info', { merchant_name: 'Bistro Libertine' });
-    expect(r.success).toBe(true);
-    expect(r.merchant.city).toBe('Lugano');
-  });
-
-  it('returns an error and possible suggestions when the name does not match', async () => {
-    const src = createBtcMapToolSource();
-    const r = await exec(src, 'get_merchant_info', { merchant_name: 'Nonexistent Merchant Name' });
-    expect(r.success).toBe(false);
-    expect(typeof r.error).toBe('string');
-  });
+  it('clamps limit to 1–20 with a default of 10', async () => {
+    const fetchImpl: BtcMapFetch = async (q) =>
+      Array.from({ length: q.limit }, (_, i) => ({
+        id: i, name: `m${i}`, lat: 0, lng: 0, acceptedAssets: ['lightning'],
+      })) as BtcMapMerchant[];
+    const src = createBtcMapToolSource({ location: locationOnly, fetch: fetchImpl });
 
-  it('treats a fuzzy-close name as a hit (not an error)', async () => {
-    const src = createBtcMapToolSource();
-    const r = await exec(src, 'get_merchant_info', { merchant_name: 'Pubkey' }); // PubKey
-    expect(r.success).toBe(true);
-    expect(r.merchant.name).toBe('PubKey');
-  });
+    const dflt = await exec(src, 'find_merchant_locations', {});
+    expect(dflt.merchants.length).toBe(10);
 
-  it('returns an error (no throw) when given nothing', async () => {
-    const src = createBtcMapToolSource();
-    const r = await exec(src, 'get_merchant_info', {});
-    expect(r.success).toBe(false);
-  });
-});
+    const big = await exec(src, 'find_merchant_locations', { limit: 9999 });
+    expect(big.merchants.length).toBe(20); // clamped to 20
 
-describe('BTC_MAP_SAMPLE', () => {
-  it('has a row in Lugano with Lightning support (sanity)', () => {
-    const lugano = BTC_MAP_SAMPLE.filter((m) => m.city === 'Lugano');
-    expect(lugano.length).toBeGreaterThan(0);
-    expect(lugano.every((m) => m.acceptedAssets?.includes('lightning'))).toBe(true);
+    const tiny = await exec(src, 'find_merchant_locations', { limit: -5 });
+    expect(tiny.merchants.length).toBe(1); // clamped to 1
   });
 });

package/src/knowledge/btc-map.ts

@@ -1,15 +1,15 @@
 /**
- * BTC Map tool source — exposes `find_merchant_locations` and
- * `get_merchant_info` so the agent can answer "where can I spend Bitcoin
- * near me?" using the SAME tool names on every surface.
+ * BTC Map tool source — exposes `find_merchant_locations` so the agent can
+ * answer "where can I spend Bitcoin near me?" using the SAME tool name on
+ * every surface.
  *
  *   - mobile  → injects device GPS + a live BTC Map fetch
  *   - desktop → injects a live fetch (or a server-side cache)
- *   - eval / playground → no injection, falls back to the bundled offline list
  *
  * Pure data + orchestration — NO network in core. The host injects the
- * `location` resolver and the `fetch` adapter; without them the source still
- * runs against an offline `Merchant[]` so the skill is never dead on arrival.
+ * `location` resolver and the `fetch` adapter. Without them the tool returns
+ * a clear error: there is NO offline / sample fallback (intentional — fake
+ * data is worse than a clean failure that tells the user what's wrong).
  *
  * The result shape mirrors what rate's host returns today, so a mobile host
  * can swap its bespoke merchant tools for this factory verbatim.
@@ -20,7 +20,6 @@ import type { ToolSource } from '../tools/source.js';
 import type { Merchant } from './merchants.js';
 
 const FIND = 'find_merchant_locations';
-const INFO = 'get_merchant_info';
 
 /** A geographic point + optional human label. */
 export interface LatLng {
@@ -34,8 +33,9 @@ export interface LatLng {
 
 /**
  * Host-injected location resolver. Core is platform-agnostic — RN has GPS,
- * Node typically doesn't. When omitted, `find_merchant_locations` falls back
- * to the offline merchant list.
+ * Node typically doesn't. When the host can't resolve a location (no GPS, no
+ * geocoder, or `near_address` won't geocode), the tool returns a clean
+ * `success:false` error instead of falling back to fake data.
  */
 export interface LocationProvider {
   /** Resolve "near me" — the device location, or null if unavailable. */
@@ -72,126 +72,10 @@ export interface BtcMapToolOptions {
   location?: LocationProvider;
   /** Hit a live BTC Map (or your own cache). Host-injected — no network in core. */
   fetch?: BtcMapFetch;
-  /** Offline list used when no location/fetch is available. Defaults to BTC_MAP_SAMPLE. */
-  offlineMerchants?: Merchant[];
   /** Default for `limit` when the caller doesn't set one. Default 10. */
   k?: number;
 }
 
-/** A tiny, hand-curated sample so the skill works offline out of the box. */
-export const BTC_MAP_SAMPLE: Merchant[] = [
-  {
-    id: 'lugano-bitcoinpeople-cafe',
-    name: 'Bitcoin People Café',
-    category: 'cafe',
-    address: 'Via Pessina 12',
-    city: 'Lugano',
-    lat: 46.0037,
-    lng: 8.9511,
-    acceptedAssets: ['lightning', 'onchain'],
-    description: 'Specialty espresso bar; Plan ₿ Lugano partner.',
-  },
-  {
-    id: 'lugano-bistro-libertine',
-    name: 'Bistro Libertine',
-    category: 'restaurant',
-    address: 'Piazza della Riforma 3',
-    city: 'Lugano',
-    lat: 46.004,
-    lng: 8.952,
-    acceptedAssets: ['lightning', 'usdt', 'onchain'],
-    description: 'Italian-Swiss bistro, lunch + dinner. Accepts Tether on Liquid.',
-  },
-  {
-    id: 'lugano-bookshop-volta',
-    name: 'Libreria Volta',
-    category: 'shop',
-    address: 'Via Cattedrale 8',
-    city: 'Lugano',
-    lat: 46.0055,
-    lng: 8.9499,
-    acceptedAssets: ['lightning'],
-    description: 'Independent bookshop; Italian, English and German titles.',
-  },
-  {
-    id: 'lisbon-meson-andaluz',
-    name: 'Mesón Andaluz',
-    category: 'restaurant',
-    address: 'Rua das Flores 42',
-    city: 'Lisbon',
-    lat: 38.71,
-    lng: -9.143,
-    acceptedAssets: ['lightning', 'onchain'],
-    description: 'Andalusian tapas in Chiado. Bitcoin accepted since 2022.',
-  },
-  {
-    id: 'lisbon-surf-bitcoin',
-    name: 'Surf & Sats',
-    category: 'shop',
-    address: 'Av. da Liberdade 180',
-    city: 'Lisbon',
-    lat: 38.7211,
-    lng: -9.1466,
-    acceptedAssets: ['lightning'],
-    description: 'Surfboard rental and lessons in Costa da Caparica.',
-  },
-  {
-    id: 'sansalvador-elzonte-hope',
-    name: 'Hope House El Zonte',
-    category: 'cafe',
-    address: 'Calle Principal',
-    city: 'El Zonte',
-    lat: 13.492,
-    lng: -89.4395,
-    acceptedAssets: ['lightning', 'onchain'],
-    description: 'Bitcoin Beach hub. Coffee, community, and a Lightning ATM.',
-  },
-  {
-    id: 'sansalvador-elzonte-garten',
-    name: 'Garten Restaurante',
-    category: 'restaurant',
-    address: 'Bitcoin Beach',
-    city: 'El Zonte',
-    lat: 13.4925,
-    lng: -89.438,
-    acceptedAssets: ['lightning'],
-    description: 'Beachfront restaurant, full Bitcoin payments since 2021.',
-  },
-  {
-    id: 'nyc-pubkey',
-    name: 'PubKey',
-    category: 'bar',
-    address: '85 Washington Pl',
-    city: 'New York',
-    lat: 40.732,
-    lng: -73.999,
-    acceptedAssets: ['lightning', 'onchain'],
-    description: 'Bitcoin bar in Greenwich Village — meetups, Lightning tap.',
-  },
-  {
-    id: 'prague-paralelni-polis',
-    name: 'Paralelní Polis',
-    category: 'cafe',
-    address: 'Dělnická 43',
-    city: 'Prague',
-    lat: 50.105,
-    lng: 14.448,
-    acceptedAssets: ['lightning', 'onchain', 'monero'],
-    description: 'Crypto-only café and hackerspace — no fiat accepted, ever.',
-  },
-  {
-    id: 'amsterdam-bitcoin-embassy',
-    name: 'Bitcoin Embassy Amsterdam',
-    category: 'cafe',
-    address: 'Nieuwezijds Voorburgwal 162',
-    city: 'Amsterdam',
-    lat: 52.374,
-    lng: 4.893,
-    acceptedAssets: ['lightning', 'onchain'],
-    description: 'Co-working café and meetup hub, Lightning tap on draft beer.',
-  },
-];
-
 /** Clamp a value to a numeric range, returning the default when input is bad. */
 function clamp(n: unknown, lo: number, hi: number, dflt: number): number {
   const v = Number(n);
@@ -199,23 +83,6 @@ function clamp(n: unknown, lo: number, hi: number, dflt: number): number {
   return Math.min(hi, Math.max(lo, v));
 }
 
-/** Substring scoring used by the offline fallback (matches the old behavior). */
-function fuzzyScore(query: string, text: string): number {
-  const q = query.toLowerCase();
-  const t = text.toLowerCase();
-  if (!q) return 1;
-  if (t.includes(q)) return 1;
-  let hits = 0;
-  let qi = 0;
-  for (let i = 0; i < t.length && qi < q.length; i++) {
-    if (t[i] === q[qi]) {
-      hits++;
-      qi++;
-    }
-  }
-  return hits / q.length;
-}
-
 /** Map a Merchant → the response row the model sees (stable for rate parity). */
 function row(m: BtcMapMerchant) {
   return {
@@ -234,49 +101,18 @@ function row(m: BtcMapMerchant) {
   };
 }
 
-/** Offline search: substring + optional category over the bundled list. */
-function searchOffline(
-  merchants: Merchant[],
-  query: string | undefined,
-  category: string | undefined,
-  limit: number,
-): Merchant[] {
-  let filtered = merchants;
-  if (category) {
-    const c = category.toLowerCase().trim();
-    filtered = filtered.filter((m) => (m.category ?? '').toLowerCase() === c);
-  }
-  const q = (query ?? '').trim();
-  if (q.length >= 2) {
-    filtered = filtered
-      .map((m) => {
-        const hay = `${m.name ?? ''} ${m.description ?? ''} ${m.address ?? ''} ${m.city ?? ''}`;
-        const score =
-          fuzzyScore(q, m.name ?? '') * 3 +
-          fuzzyScore(q, m.address ?? '') * 2 +
-          fuzzyScore(q, hay) * 1;
-        return { m, score };
-      })
-      .filter((x) => x.score > 0.3)
-      .sort((a, b) => b.score - a.score)
-      .map((x) => x.m);
-  }
-  return filtered.slice(0, limit);
-}
-
 /**
- * Build a ToolSource exposing `find_merchant_locations` + `get_merchant_info`.
+ * Build a ToolSource exposing `find_merchant_locations`.
  *
- * Resolution order for `find_merchant_locations`:
+ * Resolution order:
  *   1. `near_address` provided → opts.location.geocode → opts.fetch (live)
  *   2. opts.location.getCurrent → opts.fetch (live)
- *   3. fall through to offline substring search over opts.offlineMerchants
  *
- * Any step that fails silently falls through to the next, so the skill is
- * always answerable.
+ * Any step that fails returns `{success:false, error}` with a message that
+ * tells the user (and the model) what's actually wrong — no fake-data
+ * fallback. Either we have a real merchant list or we say we don't.
  */
 export function createBtcMapToolSource(opts: BtcMapToolOptions = {}): ToolSource {
-  const offline = opts.offlineMerchants ?? BTC_MAP_SAMPLE;
   const defaultLimit = opts.k ?? 10;
 
   const find: ToolDef = {
@@ -285,56 +121,25 @@ export function createBtcMapToolSource(opts: BtcMapToolOptions = {}): ToolSource
       "Find Bitcoin-accepting merchants near the user using live BTC Map data " +
       "and the device's real location when available. Use when the user wants " +
       'merchants, shops, restaurants, cafes, bars, ATMs, or places to spend ' +
-      'Bitcoin nearby. Pass ONLY the fields the user actually named — do not ' +
-      'invent constraints (e.g. omit `query` when they just say "near me").',
+      'Bitcoin nearby. Map the request to the smallest useful set of arguments. ' +
+      'For generic "where can I spend sats / bitcoin merchants in X" use only ' +
+      'near_address (or nothing). Never put "sats", "btc", "bitcoin" or spend verbs ' +
+      'into query or category — this source is already Bitcoin-only. When uncertain ' +
+      'or the request is generic, prefer fewer fields rather than guessing. ' +
+      'The returned merchants (or a clean error) are the only factual source — ' +
+      'never invent places.',
     parameters: {
       type: 'object',
       properties: {
-        query: { type: 'string', description: 'Optional filter for merchant name or type, e.g. "coffee"' },
-        category: { type: 'string', description: 'restaurant | cafe | bar | shop | grocery | lodging | atm' },
-        near_address: { type: 'string', description: 'Address/city to search around instead of the current location' },
-        radius_km: { type: 'number', description: 'Search radius in km (0.25–50, default 5)' },
-        limit: { type: 'number', description: 'Max number of results (1–20, default 10)' },
+        query: { type: 'string', description: 'OPTIONAL — a name, food type, or descriptive term implied by the user (e.g. "coffee", "pizza", "food", "atm", "shop"). Good for vague or natural phrasing. **OMIT** for generic "spend sats", "where can I spend", "merchants", or "places to spend btc". **NEVER** include "sats", "btc", "bitcoin", "spend", or currency terms — the source is already Bitcoin-only and this over-filters to zero results.' },
+        category: { type: 'string', description: 'OPTIONAL — set only when the request cleanly matches one specific allowed venue type: restaurant, cafe, bar, shop, grocery, lodging, atm. Leave empty for generic or mixed "spend sats / where to spend bitcoin" requests. Never guess a category (e.g. "shop") for a generic spend query. Never use generic nouns like merchant/place/store as the category value.' },
+        near_address: { type: 'string', description: 'City or address to search around when the user names a location instead of (or with) "near me". e.g. "Lugano", "Lisbon", "the center". The host will attempt to geocode it.' },
+        radius_km: { type: 'number', description: 'OPTIONAL — search radius in km (0.25–50). OMIT entirely unless the user explicitly named a distance ("within 2 km"). The default (5) is already applied server-side.' },
+        limit: { type: 'number', description: 'OPTIONAL — max results (1–20, default 10). Omit unless the user named a count.' },
       },
     },
   };
 
-  const info: ToolDef = {
-    name: INFO,
-    description:
-      'Get detailed information about one specific merchant by id or name — ' +
-      'full address, accepted assets, contact details. Use after ' +
-      'find_merchant_locations when the user asks for more on a specific result.',
-    parameters: {
-      type: 'object',
-      properties: {
-        merchant_id: { type: 'string', description: 'Merchant id from find_merchant_locations (string or number)' },
-        merchant_name: { type: 'string', description: 'Merchant name (used when id is unknown)' },
-      },
-    },
-  };
-
-  async function tryLive(
-    center: LatLng,
-    radiusMeters: number,
-    query: string | undefined,
-    category: string | undefined,
-    limit: number,
-  ): Promise<BtcMapMerchant[] | null> {
-    if (!opts.fetch) return null;
-    try {
-      return await opts.fetch({
-        center: { lat: center.lat, lng: center.lng },
-        radiusMeters,
-        query,
-        category,
-        limit,
-      });
-    } catch {
-      return null;
-    }
-  }
-
   async function resolveCenter(near_address: string | undefined): Promise<LatLng | null> {
     if (!opts.location) return null;
     if (near_address && near_address.trim().length >= 2 && opts.location.geocode) {
@@ -342,7 +147,7 @@ export function createBtcMapToolSource(opts: BtcMapToolOptions = {}): ToolSource
         const pt = await opts.location.geocode(near_address);
         if (pt) return { ...pt, label: near_address, precise: false };
       } catch {
-        /* fall through */
+        /* geocode failed — fall through to getCurrent */
       }
     }
     try {
@@ -360,87 +165,67 @@ export function createBtcMapToolSource(opts: BtcMapToolOptions = {}): ToolSource
     const limit = clamp(args.limit, 1, 20, defaultLimit);
     const radiusMeters = radius_km * 1000;
 
-    // 1 + 2. Try the live path when we can.
+    // Live path requires BOTH a location resolver and a fetch adapter — they
+    // are host-injected. Without either, the tool can't produce real merchant
+    // data, and we refuse to invent.
+    if (!opts.fetch) {
+      return {
+        success: false,
+        error:
+          'Merchant search is unavailable: the host has not injected a BTC Map fetch adapter. ' +
+          'No offline / sample data is used — connect a fetcher or try again later.',
+      };
+    }
     const center = await resolveCenter(near_address);
-    if (center) {
-      const live = await tryLive(center, radiusMeters, query, category, limit);
-      if (live) {
-        const where = center.label || (center.precise ? 'your location' : 'the default location');
-        return {
-          success: true,
-          source: 'btcmap',
-          precise_location: !!center.precise,
-          center: { lat: center.lat, lng: center.lng },
-          merchants: live.map(row),
-          total_found: live.length,
-          message:
-            live.length > 0
-              ? `Found ${live.length} Bitcoin merchant${live.length === 1 ? '' : 's'} near ${where}${query ? ` matching "${query}"` : ''}.`
-              : `No Bitcoin merchants found within ${radius_km} km of ${where}. Try widening the radius.`,
-        };
-      }
+    if (!center) {
+      return {
+        success: false,
+        error: near_address
+          ? `Could not locate "${near_address}". Check the spelling or try a nearby city.`
+          : 'Could not determine your location. Pass `near_address` (a city or address) to search a specific area.',
+      };
     }
 
-    // 3. Offline fallback.
-    const found = searchOffline(offline, query, category, limit);
-    return {
-      success: true,
-      source: 'offline',
-      precise_location: false,
-      merchants: found.map(row),
-      total_found: found.length,
-      message:
-        found.length > 0
-          ? `Showing ${found.length} merchant${found.length === 1 ? '' : 's'} from the offline list${query ? ` matching "${query}"` : ''}.`
-          : `No merchants in the offline list matched${query ? ` "${query}"` : ''}. The host hasn't injected a live BTC Map fetch.`,
-    };
-  }
-
-  async function getInfo(args: Record<string, unknown>): Promise<unknown> {
-    const idArg = args.merchant_id;
-    const nameArg = args.merchant_name ? String(args.merchant_name).trim() : '';
-    let m: Merchant | undefined;
-    if (idArg !== undefined && idArg !== null && idArg !== '') {
-      const want = String(idArg);
-      m = offline.find((x) => String(x.id) === want);
-    }
-    if (!m && nameArg.length >= 2) {
-      const q = nameArg.toLowerCase();
-      m =
-        offline.find((x) => (x.name ?? '').toLowerCase() === q) ??
-        offline
-          .map((x) => ({ x, score: fuzzyScore(q, (x.name ?? '').toLowerCase()) }))
-          .filter((r) => r.score > 0.5)
-          .sort((a, b) => b.score - a.score)[0]?.x;
-    }
-    if (!m) {
-      const suggestions = nameArg
-        ? offline
-            .map((x) => ({ name: x.name ?? '', score: fuzzyScore(nameArg.toLowerCase(), (x.name ?? '').toLowerCase()) }))
-            .filter((r) => r.score > 0.3)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, 3)
-            .map((r) => r.name)
-        : [];
+    let merchants: BtcMapMerchant[];
+    try {
+      merchants = await opts.fetch({
+        center: { lat: center.lat, lng: center.lng },
+        radiusMeters,
+        query,
+        category,
+        limit,
+      });
+    } catch (e) {
       return {
         success: false,
-        error: `Could not find merchant${nameArg ? ` "${nameArg}"` : idArg !== undefined ? ` with id ${idArg}` : ''}.`,
-        suggestions: suggestions.length ? suggestions : undefined,
+        error: `BTC Map fetch failed: ${(e as Error)?.message ?? String(e)}.`,
       };
     }
-    return { success: true, merchant: { ...row(m as BtcMapMerchant), city: m.city } };
+
+    const where = center.label || (center.precise ? 'your location' : 'the requested area');
+    return {
+      success: true,
+      source: 'btcmap',
+      precise_location: !!center.precise,
+      center: { lat: center.lat, lng: center.lng },
+      merchants: merchants.map(row),
+      total_found: merchants.length,
+      message:
+        merchants.length > 0
+          ? `Found ${merchants.length} Bitcoin merchant${merchants.length === 1 ? '' : 's'} near ${where}${query ? ` matching "${query}"` : ''}.`
+          : `No Bitcoin merchants found within ${radius_km} km of ${where}. Try widening the radius.`,
+    };
   }
 
   async function execute(name: string, args: Record<string, unknown>): Promise<unknown> {
     if (name === FIND) return findLocations(args);
-    if (name === INFO) return getInfo(args);
     throw new Error(`btc-map: unknown tool "${name}"`);
   }
 
   return {
     id: 'btc-map',
-    listTools: () => [find, info],
-    has: (name) => name === FIND || name === INFO,
+    listTools: () => [find],
+    has: (name) => name === FIND,
     execute,
   };
 }