@ouro.bot/cli 0.1.0-alpha.234 → 0.1.0-alpha.236

package/changelog.json

@@ -2,9 +2,20 @@
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
     {
-      "version": "0.1.0-alpha.234",
+      "version": "0.1.0-alpha.236",
       "changes": [
-        "fix(mcp): add retry logic for senseTurn daemon routing — retries on ECONNREFUSED, ENOENT, and empty response with exponential backoff (1s, 2s, 4s)"
+        "fix(engine): provider-aware retry classification — retries now use both generic isTransientError AND provider classifyError",
+        "feat(engine): retry instrumentation — engine.provider_retry / engine.provider_retry_skip events with full diagnostics"
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.235",
+      "changes": [
+        "fix: MCP tool double-prefix \u2014 tools already prefixed by server name no longer get a redundant second prefix in the unified registry.",
+        "feat: Open-Meteo zero-auth weather \u2014 replaced OpenWeatherMap with Open-Meteo forecast + geocoding API. Weather now works without any API key or credential provisioning.",
+        "feat: expanded ISO/FIPS divergence table \u2014 21 new entries for correct travel advisory resolution across all major divergent country codes.",
+        "fix: BitwardenCredentialStore retry logic \u2014 exponential backoff with configurable retries for transient bw CLI failures, plus bw-not-installed error.",
+        "chore: travel MCP packages (Duffel, Expedia) status confirmed GitHub-only, not published to npm."
       ]
     },
     {

package/dist/heart/core.js

@@ -959,20 +959,48 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 callbacks.onError(new Error("context trimmed, retrying..."), "transient");
                 continue;
             }
-            // Transient errors: retry with exponential backoff
-            if (isTransientError(e) && retryCount < MAX_RETRIES) {
+            // Transient errors: retry with exponential backoff.
+            // Two-layer detection: generic isTransientError (HTTP codes, network patterns)
+            // PLUS provider-specific classifyError (catches SDK-wrapped errors that
+            // generic detection might miss).
+            const errorForClassification = e instanceof Error ? e : /* v8 ignore next -- defensive @preserve */ new Error(String(e));
+            let providerClassification;
+            try {
+                providerClassification = providerRuntime.classifyError(errorForClassification);
+            }
+            catch {
+                /* v8 ignore next -- defensive: classifyError should not throw @preserve */
+                providerClassification = "unknown";
+            }
+            const retryableByClassification = providerClassification === "rate-limit"
+                || providerClassification === "server-error"
+                || providerClassification === "network-error";
+            const retryableByGeneric = isTransientError(e);
+            const shouldRetry = (retryableByGeneric || retryableByClassification) && retryCount < MAX_RETRIES;
+            (0, runtime_1.emitNervesEvent)({
+                level: shouldRetry ? "info" : "warn",
+                event: shouldRetry ? "engine.provider_retry" : "engine.provider_retry_skip",
+                component: "engine",
+                message: shouldRetry
+                    ? `provider error is retryable (attempt ${retryCount + 1}/${MAX_RETRIES})`
+                    : `provider error is not retryable or retries exhausted`,
+                meta: {
+                    provider: providerRuntime.id,
+                    model: providerRuntime.model,
+                    retryCount,
+                    maxRetries: MAX_RETRIES,
+                    retryableByGeneric,
+                    retryableByClassification,
+                    providerClassification,
+                    errorMessage: errorForClassification.message.slice(0, 200),
+                    httpStatus: e.status ?? null,
+                },
+            });
+            if (shouldRetry) {
                 retryCount++;
                 const delay = RETRY_BASE_MS * Math.pow(2, retryCount - 1);
-                let classification;
-                try {
-                    classification = providerRuntime.classifyError(e instanceof Error ? e : /* v8 ignore next -- defensive: errors are always Error instances @preserve */ new Error(String(e)));
-                }
-                catch {
-                    /* v8 ignore next -- defensive: classifyError should not throw @preserve */
-                    classification = classifyTransientError(e);
-                }
                 /* v8 ignore next -- defensive: all classifications have labels @preserve */
-                const cause = TRANSIENT_RETRY_LABELS[classification] ?? classification;
+                const cause = TRANSIENT_RETRY_LABELS[providerClassification] ?? providerClassification;
                 callbacks.onError(new Error(`${cause}, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
                 // Wait with abort support
                 const aborted = await new Promise((resolve) => {
@@ -995,14 +1023,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 providerRuntime.resetTurnState(messages);
                 continue;
             }
-            terminalError = e instanceof Error ? e : new Error(String(e));
-            try {
-                terminalErrorClassification = providerRuntime.classifyError(terminalError);
-            }
-            catch {
-                /* v8 ignore next -- defensive: classifyError should not throw @preserve */
-                terminalErrorClassification = "unknown";
-            }
+            terminalError = errorForClassification;
+            terminalErrorClassification = providerClassification;
             /* v8 ignore start — auth-failure guidance: tested via provider error classification tests @preserve */
             if (terminalErrorClassification === "auth-failure") {
                 const agentName = (0, identity_2.getAgentName)();

package/dist/repertoire/bitwarden-store.js

@@ -22,6 +22,10 @@ function execBw(args, sessionToken) {
     return new Promise((resolve, reject) => {
         (0, node_child_process_1.execFile)("bw", args, { timeout: 30_000, env }, (err, stdout) => {
             if (err) {
+                if (isBwNotInstalled(err)) {
+                    reject(new Error("bw CLI not found. Install from https://bitwarden.com/help/cli/"));
+                    return;
+                }
                 reject(new Error(`bw CLI error: ${err.message}`));
                 return;
             }
@@ -29,6 +33,27 @@ function execBw(args, sessionToken) {
         });
     });
 }
+/** Check if the error indicates the bw CLI binary is not installed. */
+function isBwNotInstalled(err) {
+    const msg = err.message.toLowerCase();
+    const code = err.code;
+    return code === "ENOENT" || msg.includes("enoent") || msg.includes("not found") || msg.includes("command not found");
+}
+/** Check if the error is transient (network/timeout) and worth retrying. */
+function isTransientError(err) {
+    const msg = err.message.toLowerCase();
+    return (msg.includes("econnrefused") ||
+        msg.includes("etimedout") ||
+        msg.includes("enotfound") ||
+        msg.includes("socket hang up") ||
+        msg.includes("503") ||
+        msg.includes("server unavailable"));
+}
+const MAX_RETRIES = 3;
+const BASE_BACKOFF_MS = 1000;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 // ---------------------------------------------------------------------------
 // BitwardenCredentialStore
 // ---------------------------------------------------------------------------
@@ -48,15 +73,50 @@ class BitwardenCredentialStore {
     /**
      * Ensure the bw CLI is authenticated and unlocked.
      * Handles three states: logged out → login, locked → unlock, already unlocked → no-op.
+     * Retries transient failures (network/timeout) up to MAX_RETRIES with exponential backoff.
      */
     async login() {
+        let lastError;
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            try {
+                await this.loginAttempt();
+                return;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: loginAttempt always throws Error instances @preserve */
+                lastError = err instanceof Error ? err : new Error(String(err));
+                // Don't retry non-transient errors (auth failures, bw not installed)
+                if (!isTransientError(lastError)) {
+                    throw lastError;
+                }
+                // Don't retry after final attempt
+                if (attempt === MAX_RETRIES - 1)
+                    break;
+                const backoffMs = BASE_BACKOFF_MS * Math.pow(2, attempt);
+                (0, runtime_1.emitNervesEvent)({
+                    event: "repertoire.bw_login_retry",
+                    component: "repertoire",
+                    message: `bw login attempt ${attempt + 1} failed, retrying in ${backoffMs}ms`,
+                    meta: { attempt: attempt + 1, backoffMs, reason: lastError.message },
+                });
+                await delay(backoffMs);
+            }
+        }
+        throw lastError;
+    }
+    /** Single login attempt — called by login() retry loop. */
+    async loginAttempt() {
         // Check current status
         let status = {};
         try {
             const raw = await execBw(["status"]);
             status = JSON.parse(raw);
         }
-        catch {
+        catch (err) {
+            // If bw CLI is not installed or a transient error, propagate it for retry
+            if (err instanceof Error && (isBwNotInstalled(err) || isTransientError(err))) {
+                throw err;
+            }
             // CLI not configured or broken — proceed with full setup
         }
         // Configure server URL if needed (only works when logged out)

package/dist/repertoire/mcp-tools.js

@@ -18,7 +18,9 @@ function mcpToolsAsDefinitions(mcpManager) {
         tool: {
             type: "function",
             function: {
-                name: `${entry.server}_${tool.name}`,
+                name: tool.name.startsWith(`${entry.server}_`) || tool.name === entry.server
+                    ? tool.name
+                    : `${entry.server}_${tool.name}`,
                 description: tool.description || `MCP tool: ${tool.name} (server: ${entry.server})`,
                 parameters: tool.inputSchema ?? { type: "object", properties: {} },
             },

package/dist/repertoire/travel-api-client.js

@@ -3,12 +3,13 @@
  * Travel API client module.
  *
  * Provides HTTP clients for:
- * - OpenWeatherMap (query-param auth via vault)
+ * - Open-Meteo weather forecast (no auth, WMO weather codes)
  * - US State Dept Travel Advisories (no auth)
  * - Nominatim Geocoding (no auth, requires User-Agent)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRAVEL_ADVISORY_RSS_URL = void 0;
+exports.TRAVEL_ADVISORY_RSS_URL = exports.WMO_WEATHER_CODES = void 0;
+exports.wmoWeatherDescription = wmoWeatherDescription;
 exports.getWeather = getWeather;
 exports.getWeatherByCity = getWeatherByCity;
 exports.isoToCountryName = isoToCountryName;
@@ -20,47 +21,105 @@ exports.geocode = geocode;
 exports.reverseGeocode = reverseGeocode;
 exports.searchPOI = searchPOI;
 const runtime_1 = require("../nerves/runtime");
-const credential_access_1 = require("./credential-access");
-// --- OpenWeatherMap ---
-/** Domain used for weather API key credential retrieval. */
-const WEATHER_CREDENTIAL_DOMAIN = "api.openweathermap.org";
-async function getWeatherApiKey() {
-    const store = (0, credential_access_1.getCredentialStore)();
-    return store.getRawSecret(WEATHER_CREDENTIAL_DOMAIN, "password");
+// --- Open-Meteo Weather (zero auth) ---
+const OPEN_METEO_FORECAST = "https://api.open-meteo.com/v1/forecast";
+const OPEN_METEO_GEOCODING = "https://geocoding-api.open-meteo.com/v1/search";
+const OPEN_METEO_HEADERS = {
+    "User-Agent": "Ouroboros/1.0 (https://github.com/ouroborosbot/ouroboros)",
+    Accept: "application/json",
+};
+/**
+ * WMO weather interpretation codes (WW) to human-readable descriptions.
+ * Spec: https://www.nodc.noaa.gov/archive/arc0021/0002199/1.1/data/0-data/HTML/WMO-CODE/WMO4677.HTM
+ */
+exports.WMO_WEATHER_CODES = {
+    0: "clear sky",
+    1: "mainly clear",
+    2: "partly cloudy",
+    3: "overcast",
+    45: "fog",
+    48: "depositing rime fog",
+    51: "light drizzle",
+    53: "moderate drizzle",
+    55: "dense drizzle",
+    56: "light freezing drizzle",
+    57: "dense freezing drizzle",
+    61: "slight rain",
+    63: "moderate rain",
+    65: "heavy rain",
+    66: "light freezing rain",
+    67: "heavy freezing rain",
+    71: "slight snowfall",
+    73: "moderate snowfall",
+    75: "heavy snowfall",
+    77: "snow grains",
+    80: "slight rain showers",
+    81: "moderate rain showers",
+    82: "violent rain showers",
+    85: "slight snow showers",
+    86: "heavy snow showers",
+    95: "thunderstorm",
+    96: "thunderstorm with slight hail",
+    99: "thunderstorm with heavy hail",
+};
+/** Convert a WMO weather code to a human-readable description. */
+function wmoWeatherDescription(code) {
+    return exports.WMO_WEATHER_CODES[code] ?? "unknown";
 }
 async function getWeather(lat, lon) {
     return withNervesEvents("getWeather", { lat, lon }, async () => {
-        const apiKey = await getWeatherApiKey();
-        const url = `https://api.openweathermap.org/data/2.5/weather?lat=${lat}&lon=${lon}&appid=${apiKey}&units=metric`;
-        const res = await fetch(url);
+        const url = `${OPEN_METEO_FORECAST}?latitude=${lat}&longitude=${lon}` +
+            `&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,weather_code` +
+            `&daily=temperature_2m_max,temperature_2m_min,weather_code` +
+            `&timezone=auto`;
+        const res = await fetch(url, { headers: OPEN_METEO_HEADERS });
         if (!res.ok) {
-            throw new Error(`OpenWeatherMap API error: ${res.status} ${res.statusText}`);
+            throw new Error(`Open-Meteo API error: ${res.status} ${res.statusText}`);
         }
         const data = await res.json();
-        return parseWeatherResponse(data);
+        return parseOpenMeteoResponse(data, lat, lon);
     });
 }
 async function getWeatherByCity(city) {
     return withNervesEvents("getWeatherByCity", { city }, async () => {
-        const apiKey = await getWeatherApiKey();
-        const url = `https://api.openweathermap.org/data/2.5/weather?q=${encodeURIComponent(city)}&appid=${apiKey}&units=metric`;
-        const res = await fetch(url);
+        // Step 1: geocode the city name via Open-Meteo geocoding
+        const geoUrl = `${OPEN_METEO_GEOCODING}?name=${encodeURIComponent(city)}&count=1&language=en`;
+        const geoRes = await fetch(geoUrl, { headers: OPEN_METEO_HEADERS });
+        if (!geoRes.ok) {
+            throw new Error(`Open-Meteo geocoding error: ${geoRes.status} ${geoRes.statusText}`);
+        }
+        const geoData = await geoRes.json();
+        const results = geoData.results;
+        if (!results || results.length === 0) {
+            throw new Error(`No location found for city "${city}"`);
+        }
+        const loc = results[0];
+        // Step 2: fetch forecast for the resolved coordinates
+        const url = `${OPEN_METEO_FORECAST}?latitude=${loc.latitude}&longitude=${loc.longitude}` +
+            `&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,weather_code` +
+            `&daily=temperature_2m_max,temperature_2m_min,weather_code` +
+            `&timezone=auto`;
+        const res = await fetch(url, { headers: OPEN_METEO_HEADERS });
         if (!res.ok) {
-            throw new Error(`OpenWeatherMap API error: ${res.status} ${res.statusText}`);
+            throw new Error(`Open-Meteo API error: ${res.status} ${res.statusText}`);
         }
         const data = await res.json();
-        return parseWeatherResponse(data);
+        return parseOpenMeteoResponse(data, loc.latitude, loc.longitude, loc.name, loc.country_code);
     });
 }
-function parseWeatherResponse(data) {
+function parseOpenMeteoResponse(data, lat, lon, cityName, countryCode) {
+    const current = data.current ?? {};
+    const daily = data.daily ?? {};
     return {
-        temperature: data.main.temp,
-        feelsLike: data.main.feels_like,
-        description: data.weather?.[0]?.description ?? "unknown",
-        humidity: data.main.humidity,
-        windSpeed: data.wind.speed,
-        city: data.name,
-        country: data.sys.country,
+        temperature: current.temperature_2m ?? 0,
+        feelsLike: current.apparent_temperature ?? 0,
+        description: wmoWeatherDescription(current.weather_code ?? -1),
+        humidity: current.relative_humidity_2m ?? 0,
+        windSpeed: current.wind_speed_10m ?? 0,
+        city: cityName ?? `${lat},${lon}`,
+        country: countryCode ?? "",
+        dailyHigh: daily.temperature_2m_max?.[0],
+        dailyLow: daily.temperature_2m_min?.[0],
     };
 }
 // --- US State Dept Travel Advisories ---
@@ -79,31 +138,52 @@ exports.TRAVEL_ADVISORY_RSS_URL = "https://travel.state.gov/_res/rss/TAsTWs.xml"
  * This table handles the ~30 codes where they diverge.
  */
 const ISO_FIPS_DIVERGENCE = {
+    AG: "Antigua and Barbuda", // FIPS: AC
     AT: "Austria", // FIPS: AU
     AU: "Australia", // FIPS: AS
     BD: "Bangladesh", // FIPS: BG
+    BH: "Bahrain", // FIPS: BA
     BN: "Brunei", // FIPS: BX
     BO: "Bolivia", // FIPS: BL
+    BS: "Bahamas", // FIPS: BF
+    BW: "Botswana", // FIPS: BC
+    CD: "Congo (Kinshasa)", // FIPS: CG
     CH: "Switzerland", // FIPS: SZ
+    CI: "Cote d'Ivoire", // FIPS: IV
+    CL: "Chile", // FIPS: CI
+    CN: "China", // FIPS: CH
     CZ: "Czechia", // FIPS: EZ
     DE: "Germany", // FIPS: GM
+    DK: "Denmark", // FIPS: DA
+    DO: "Dominican Republic", // FIPS: DR
+    DZ: "Algeria", // FIPS: AG
     ES: "Spain", // FIPS: SP
     FI: "Finland", // FIPS: FI → same, but title might say "Finland"
     GQ: "Equatorial Guinea", // FIPS: EK
     HR: "Croatia", // FIPS: HR → same
     IE: "Ireland", // FIPS: EI
+    IL: "Israel", // FIPS: IS
+    JP: "Japan", // FIPS: JA
     KP: "North Korea", // FIPS: KN
     KR: "South Korea", // FIPS: KS
     LT: "Lithuania", // FIPS: LH
+    MA: "Morocco", // FIPS: MO
     MM: "Burma", // FIPS: BM (State Dept uses "Burma (Myanmar)")
+    NG: "Nigeria", // FIPS: NI
     NO: "Norway", // FIPS: NO → same
     PH: "Philippines", // FIPS: RP
+    PT: "Portugal", // FIPS: PO
     RO: "Romania", // FIPS: RO → same
     SE: "Sweden", // FIPS: SW
+    SG: "Singapore", // FIPS: SN
     TL: "Timor-Leste", // FIPS: TT
+    TR: "Turkey", // FIPS: TU
     TW: "Taiwan", // FIPS: TW → same
+    UA: "Ukraine", // FIPS: UP
     VA: "Holy See", // FIPS: VT
+    VN: "Vietnam", // FIPS: VM
     YE: "Yemen", // FIPS: YM
+    ZA: "South Africa", // FIPS: SF
 };
 /**
  * Look up the expected country name for an ISO alpha-2 code,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.234",
+  "version": "0.1.0-alpha.236",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

package/skills/travel-planning.md

@@ -117,7 +117,7 @@ Track and reference these travel preferences:
 ## Tool Reference
 
 ### Native Tools (always available)
-- `weather_lookup` - Current weather by city or coordinates
+- `weather_lookup` - Current weather and daily forecast by city or coordinates (Open-Meteo, zero config)
 - `travel_advisory` - US State Dept advisory by country code
 - `geocode_search` - Location/POI search with coordinates
 - `credential_get` - Check credential metadata for a domain (never returns passwords)