ray-finance 0.3.7 → 0.4.0

package/README.md

@@ -42,7 +42,7 @@ Tell Ray about your family, goals, and financial strategy once. From then on, ev
 
 ### Set it and forget it
 
-- **Bank sync via Plaid** — Connect checking, savings, credit cards, investments, and loans. Supports 18 countries: 🇺🇸 United States, 🇬🇧 United Kingdom, 🇨🇦 Canada, 🇫🇷 France, 🇩🇪 Germany, 🇪🇸 Spain, 🇮🇹 Italy, 🇳🇱 Netherlands, 🇮🇪 Ireland, 🇵🇱 Poland, 🇩🇰 Denmark, 🇳🇴 Norway, 🇸🇪 Sweden, 🇪🇪 Estonia, 🇱🇹 Lithuania, 🇱🇻 Latvia, 🇵🇹 Portugal, and 🇧🇪 Belgium.
+- **Bank sync via Plaid** — Connect checking, savings, credit cards, investments, and loans. Supports 🇺🇸 United States, 🇬🇧 United Kingdom, and 🇨🇦 Canada.
 - **Scheduled daily sync** — Automatic bank sync via launchd (macOS) or cron (Linux).
 - **Auto-recategorization** — Define rules to automatically re-label transactions.
 - **Export/import** — Back up and restore your financial data.
@@ -69,7 +69,7 @@ ray --demo alerts       # financial alerts
 ray --demo transactions # recent transactions
 ```
 
-The dashboard commands work with no setup at all. To also try the AI chat with demo data, run `ray setup` first and add an [Anthropic API key](https://console.anthropic.com) or Ray API key — then `ray --demo` will start an interactive session where you can ask questions about the fake portfolio.
+The dashboard commands work with no setup at all. To also try the AI chat with demo data, run `ray setup` first and add an API key (Anthropic, OpenAI, or any OpenAI-compatible provider) — then `ray --demo` will start an interactive session where you can ask questions about the fake portfolio.
 
 When you're ready to connect real accounts, run `ray link`.
 
@@ -92,12 +92,13 @@ We handle the API keys. Your data stays local. $10/mo.
 
 ### Bring your own keys
 
-Bring your own Anthropic and Plaid credentials. Free forever.
+Bring your own AI and Plaid credentials. Free forever.
 
-1. Enter your Anthropic API key ([get one](https://console.anthropic.com))
-2. Enter your Plaid credentials ([get free keys](https://dashboard.plaid.com/signup))
-3. Link your accounts — checking, savings, credit cards, investments, loans, mortgage
-4. Done
+1. Pick your AI provider — Anthropic, OpenAI, Ollama (local), or any OpenAI-compatible endpoint
+2. Enter your API key and pick a model
+3. Enter your Plaid credentials ([get free keys](https://dashboard.plaid.com/signup))
+4. Link your accounts — checking, savings, credit cards, investments, loans, mortgage
+5. Done
 
 ## Commands
 
@@ -147,11 +148,11 @@ Run `ray --help` to see all available commands.
                  │  scoring · alerts   │
                  └──────────┬──────────┘
                             │
-                      Claude API
+                       LLM API
                      (PII-masked)
 ```
 
-Two outbound calls: Plaid (bank sync) and Anthropic (AI chat, PII-masked). Your financial data is never stored off your machine. No telemetry. No analytics.
+Two outbound calls: Plaid (bank sync) and your AI provider (PII-masked). Supports Anthropic, OpenAI, Ollama, and any OpenAI-compatible endpoint. Your financial data is never stored off your machine. No telemetry. No analytics.
 
 ## Security & Privacy
 
@@ -159,8 +160,8 @@ Two outbound calls: Plaid (bank sync) and Anthropic (AI chat, PII-masked). Your
 - Database encrypted with AES-256 (SQLCipher)
 - Plaid access tokens encrypted at rest with AES-256-GCM
 - Config file stored with `0600` permissions
-- PII redacted before sending to Claude API
-- No data leaves your machine — only API calls to Plaid and Anthropic
+- PII redacted before sending to any AI provider
+- No data leaves your machine — only API calls to Plaid and your AI provider
 
 ## Configuration
 
@@ -181,18 +182,22 @@ Ray stores everything in `~/.ray/`:
 You can also configure Ray via environment variables or a `.env` file:
 
 ```bash
-ANTHROPIC_API_KEY=     # Anthropic API key for AI chat
-PLAID_CLIENT_ID=       # Plaid client ID
-PLAID_SECRET=          # Plaid secret key
-PLAID_ENV=production   # Plaid environment
-DB_ENCRYPTION_KEY=     # Database encryption key
-PLAID_TOKEN_SECRET=    # Key for encrypting stored Plaid tokens
-RAY_API_KEY=           # Ray API key (managed mode, replaces the above)
+ANTHROPIC_API_KEY=          # Anthropic API key (if using Anthropic)
+OPENAI_COMPATIBLE_KEY=      # API key for OpenAI or compatible provider
+OPENAI_COMPATIBLE_BASE_URL= # Base URL (e.g. https://api.openai.com/v1, http://localhost:11434/v1)
+RAY_PROVIDER=               # "anthropic" or "openai-compatible"
+RAY_MODEL=                  # Model name (e.g. claude-sonnet-4-6, gpt-4o, llama3.1)
+PLAID_CLIENT_ID=            # Plaid client ID
+PLAID_SECRET=               # Plaid secret key
+PLAID_ENV=production        # Plaid environment
+DB_ENCRYPTION_KEY=          # Database encryption key
+PLAID_TOKEN_SECRET=         # Key for encrypting stored Plaid tokens
+RAY_API_KEY=                # Ray API key (managed mode, replaces the above)
 ```
 
 ## Roadmap
 
-- [ ] Bring your own model — use any LLM provider (OpenAI, Ollama, open-source models, etc.)
+- [x] Bring your own model — use any LLM provider (OpenAI, Ollama, open-source models, etc.)
 - [ ] Daily digest email — morning summary of your finances
 
 Have an idea? [Open a PR](https://github.com/cdinnison/ray-finance/pulls).

package/dist/ai/agent.js

@@ -1,13 +1,12 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { config, useManaged, RAY_PROXY_BASE } from "../config.js";
+import { config, useManaged } from "../config.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { toolDefinitions, executeTool } from "./tools.js";
 import { getConversationHistory, saveMessage } from "./memory.js";
 import { logToolCall } from "./audit.js";
 import { redact, unredact } from "./redactor.js";
-const anthropic = new Anthropic(useManaged()
-    ? { apiKey: config.rayApiKey, baseURL: `${RAY_PROXY_BASE}/ai` }
-    : { apiKey: config.anthropicKey });
+import { createProvider } from "./providers/index.js";
+const provider = createProvider();
+const MAX_TOOL_STEPS = 10;
 function supportsThinking(model) {
     return /sonnet-4|opus-4/i.test(model);
 }
@@ -52,34 +51,29 @@ export async function handleMessage(db, userMessage, onProgress) {
     if (messages.length === 0 || messages[messages.length - 1].content !== userMessage) {
         messages.push({ role: "user", content: redact(userMessage) });
     }
-    // Extended thinking config
-    const useThinking = config.thinkingBudget > 0 && supportsThinking(config.model);
+    // Extended thinking config — only for providers that support it
+    const useThinking = config.thinkingBudget > 0
+        && provider.supportsThinking
+        && supportsThinking(config.model);
     try {
-        // Build API params
-        const apiParams = {
+        // Initial API call
+        let response = await provider.sendMessage({
             model: config.model,
-            max_tokens: useThinking ? 16000 : 4096,
+            maxTokens: useThinking ? 16000 : 4096,
             system: systemPrompt,
             tools: toolDefinitions,
             messages,
-        };
-        if (useThinking) {
-            apiParams.thinking = {
-                type: "enabled",
-                budget_tokens: config.thinkingBudget,
-            };
-        }
-        // Initial API call
-        let response = await anthropic.messages.create(apiParams);
+            thinking: useThinking
+                ? { type: "enabled", budget_tokens: config.thinkingBudget }
+                : undefined,
+        });
         // Agentic tool loop
         const startTime = Date.now();
         let toolCount = 0;
-        while (response.stop_reason === "tool_use") {
-            // Filter out thinking blocks before adding to messages
-            const assistantContent = response.content.filter((b) => b.type !== "thinking");
-            messages.push({ role: "assistant", content: assistantContent });
+        while (response.stopReason === "tool_use" && toolCount < MAX_TOOL_STEPS) {
+            messages.push({ role: "assistant", content: response.content });
             const toolResults = [];
-            for (const block of assistantContent) {
+            for (const block of response.content) {
                 if (block.type === "tool_use") {
                     toolCount++;
                     onProgress?.({
@@ -103,18 +97,30 @@ export async function handleMessage(db, userMessage, onProgress) {
                 toolCount,
                 elapsedMs: Date.now() - startTime,
             });
-            response = await anthropic.messages.create(apiParams);
+            response = await provider.sendMessage({
+                model: config.model,
+                maxTokens: useThinking ? 16000 : 4096,
+                system: systemPrompt,
+                tools: toolDefinitions,
+                messages,
+                thinking: useThinking
+                    ? { type: "enabled", budget_tokens: config.thinkingBudget }
+                    : undefined,
+            });
         }
-        // Extract text response (filter out thinking blocks), restore PII for display
+        // Extract text response, restore PII for display
         const textBlocks = response.content.filter((b) => b.type === "text");
-        const responseText = unredact(textBlocks.map((b) => b.text).join("\n"));
+        const responseText = unredact(textBlocks.map(b => b.text).join("\n"));
         // Save assistant response
         saveMessage(db, "assistant", responseText);
         return responseText || "I looked into that but couldn't formulate a response. Could you try rephrasing?";
     }
     catch (error) {
         if (error.status === 403) {
-            return "Your API key was rejected. This usually means your subscription is inactive. Run `ray billing` to check your payment status, or `ray setup` to reconfigure.";
+            if (useManaged()) {
+                return "Your API key was rejected. This usually means your subscription is inactive. Run `ray billing` to check your payment status, or `ray setup` to reconfigure.";
+            }
+            return "Your API key was rejected (403 Forbidden). Run `ray setup` to reconfigure your credentials.";
         }
         if (error.status === 401) {
             return "Invalid API key. Run `ray setup` to reconfigure your credentials.";
@@ -123,7 +129,7 @@ export async function handleMessage(db, userMessage, onProgress) {
             return "Rate limited. Wait a moment and try again.";
         }
         const safeMessage = error.status
-            ? `API error (${error.status})`
+            ? `API error (${error.status}): ${error.message || ""}`
             : error.message || "internal error";
         console.error("AI error:", safeMessage);
         return "Sorry, I had trouble processing that. Could you try again?";

package/dist/ai/insights.js

@@ -245,7 +245,7 @@ export function cliBriefing(db) {
         const change = nw.net_worth - nw.prev_net_worth;
         nwLine += change >= 0
             ? chalk.green(` +${fmtMoney(change)}`)
-            : chalk.red(` -${fmtMoney(Math.abs(change))}`);
+            : chalk.hex("#FF9F43")(` -${fmtMoney(Math.abs(change))}`);
     }
     lines.push(chalk.dim("  net worth") + nwLine);
     // Account balances
@@ -272,7 +272,7 @@ export function cliBriefing(db) {
         const cmp = compareSpending(db, lastMonthStart.toISOString().slice(0, 10), lastMonthSameDay.toISOString().slice(0, 10), monthStart.toISOString().slice(0, 10), today);
         if (cmp.period1Total > 0) {
             const diff = cmp.period2Total - cmp.period1Total;
-            const arrow = diff <= 0 ? chalk.green(`${fmtMoney(Math.abs(diff))} less`) : chalk.red(`${fmtMoney(diff)} more`);
+            const arrow = diff <= 0 ? chalk.green(`${fmtMoney(Math.abs(diff))} less`) : chalk.hex("#FF9F43")(`${fmtMoney(diff)} more`);
             lines.push(chalk.dim("  spending") + chalk.white(`  ${fmtMoney(thisMonthSpend.total)} this month`) + chalk.dim(` · `) + arrow + chalk.dim(` than this point last month`));
             // Top movers (up to 3, show both ups and downs)
             const movers = cmp.categories
@@ -282,7 +282,7 @@ export function cliBriefing(db) {
             if (movers.length > 0) {
                 const moverStrs = movers.map(m => {
                     const label = categoryLabel(m.category).toLowerCase();
-                    const color = m.diff <= 0 ? chalk.green : chalk.red;
+                    const color = m.diff <= 0 ? chalk.green : chalk.hex("#FF9F43");
                     const sign = m.diff <= 0 ? "-" : "+";
                     return `${chalk.dim(label)} ${color(`${sign}${fmtMoney(Math.abs(m.diff))}`)}`;
                 });
@@ -300,7 +300,7 @@ export function cliBriefing(db) {
         lines.push("");
         for (const b of hot) {
             const pct = Math.round(b.pct_used);
-            const color = b.over_budget ? chalk.red : chalk.yellow;
+            const color = b.over_budget ? chalk.hex("#FF9F43") : chalk.yellow;
             const bar = miniBar(b.pct_used);
             lines.push(`  ${bar}  ${color(categoryLabel(b.category).toLowerCase())} ${chalk.dim(`${pct}%`)}`);
         }
@@ -341,7 +341,7 @@ export function cliBriefing(db) {
     const score = getLatestScore(db);
     if (score) {
         lines.push("");
-        const scoreColor = score.score >= 70 ? chalk.green : score.score >= 40 ? chalk.yellow : chalk.red;
+        const scoreColor = score.score >= 70 ? chalk.green : score.score >= 40 ? chalk.yellow : chalk.hex("#FF9F43");
         let scoreLine = `  ${chalk.dim("score")}     ${scoreColor(String(score.score))}${chalk.dim("/100")}`;
         const streaks = [];
         if (score.no_restaurant_streak > 0)
@@ -362,7 +362,7 @@ function miniBar(pct) {
     const clamped = Math.max(0, Math.min(100, pct));
     const filled = Math.round((clamped / 100) * width);
     const empty = width - filled;
-    const color = pct > 100 ? chalk.red : pct > 80 ? chalk.yellow : chalk.green;
+    const color = pct > 100 ? chalk.hex("#FF9F43") : pct > 80 ? chalk.yellow : chalk.green;
     return color("▓".repeat(filled)) + chalk.dim("░".repeat(empty));
 }
 function buildScore(db) {

package/dist/ai/model.d.ts

@@ -0,0 +1,19 @@
+import { type RayConfig, type SelfHostedLlmProvider } from "../config.js";
+export interface ResolvedSelfHostedModelConfig {
+    provider: SelfHostedLlmProvider;
+    providerLabel: string;
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+}
+export declare function getResolvedSelfHostedModelConfig(input?: Partial<RayConfig>): ResolvedSelfHostedModelConfig;
+export declare function supportsThinking(input?: Partial<RayConfig>): boolean;
+export declare function createSelfHostedModel(input?: Partial<RayConfig>): any;
+export declare function getSelfHostedProviderOptions(input?: Partial<RayConfig>): {
+    anthropic: {
+        thinking: {
+            type: "enabled";
+            budgetTokens: number;
+        };
+    };
+} | undefined;

package/dist/ai/model.js

@@ -0,0 +1,47 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { config, getLlmProviderLabel, resolveSelfHostedLlmConfig } from "../config.js";
+export function getResolvedSelfHostedModelConfig(input = config) {
+    const resolved = resolveSelfHostedLlmConfig(input);
+    return {
+        ...resolved,
+        providerLabel: getLlmProviderLabel(resolved.provider),
+    };
+}
+export function supportsThinking(input = config) {
+    const { provider, model } = getResolvedSelfHostedModelConfig(input);
+    return provider === "anthropic" && /sonnet-4|opus-4/i.test(model);
+}
+export function createSelfHostedModel(input = config) {
+    const resolved = getResolvedSelfHostedModelConfig(input);
+    switch (resolved.provider) {
+        case "anthropic":
+            return createAnthropic({ apiKey: resolved.apiKey })(resolved.model);
+        case "openai":
+            return createOpenAI({ apiKey: resolved.apiKey })(resolved.model);
+        case "ollama":
+            return createOpenAICompatible({
+                name: "ollama",
+                apiKey: resolved.apiKey || "ollama",
+                baseURL: resolved.baseUrl,
+            })(resolved.model);
+    }
+}
+export function getSelfHostedProviderOptions(input = config) {
+    const resolved = getResolvedSelfHostedModelConfig(input);
+    if (resolved.provider !== "anthropic" || !supportsThinking(input)) {
+        return undefined;
+    }
+    const budgetTokens = input.thinkingBudget ?? 0;
+    if (budgetTokens <= 0)
+        return undefined;
+    return {
+        anthropic: {
+            thinking: {
+                type: "enabled",
+                budgetTokens,
+            },
+        },
+    };
+}

package/dist/ai/models-catalog.d.ts

@@ -0,0 +1,33 @@
+export interface ModelEntry {
+    id: string;
+    name: string;
+    family?: string;
+    tool_call?: boolean;
+    reasoning?: boolean;
+    cost?: {
+        input?: number;
+        output?: number;
+    };
+    limit?: {
+        context?: number;
+        output?: number;
+    };
+    release_date?: string;
+    modalities?: {
+        input?: string[];
+        output?: string[];
+    };
+}
+interface ProviderEntry {
+    id: string;
+    name: string;
+    api?: string;
+    models: Record<string, ModelEntry>;
+}
+type Catalog = Record<string, ProviderEntry>;
+export declare function getCatalog(): Promise<Catalog>;
+/** Get all models for a provider (e.g. "openai", "google", "mistral") */
+export declare function getProviderModels(catalog: Catalog, providerId: string): ModelEntry[];
+/** Look up a specific model by ID across all providers */
+export declare function lookupModel(catalog: Catalog, modelId: string): ModelEntry | undefined;
+export {};

package/dist/ai/models-catalog.js

@@ -0,0 +1,58 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+const CACHE_PATH = resolve(homedir(), ".ray", "models-cache.json");
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+const CATALOG_URL = "https://models.dev/api.json";
+async function fetchCatalog() {
+    const resp = await fetch(CATALOG_URL);
+    if (!resp.ok)
+        throw new Error(`Failed to fetch model catalog: ${resp.status}`);
+    const data = await resp.json();
+    const dir = resolve(homedir(), ".ray");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const cached = { fetchedAt: Date.now(), data };
+    writeFileSync(CACHE_PATH, JSON.stringify(cached));
+    return data;
+}
+function getCachedCatalog() {
+    if (!existsSync(CACHE_PATH))
+        return null;
+    try {
+        const cached = JSON.parse(readFileSync(CACHE_PATH, "utf-8"));
+        if (Date.now() - cached.fetchedAt > CACHE_TTL)
+            return null;
+        return cached.data;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getCatalog() {
+    const cached = getCachedCatalog();
+    if (cached)
+        return cached;
+    try {
+        return await fetchCatalog();
+    }
+    catch {
+        return {};
+    }
+}
+/** Get all models for a provider (e.g. "openai", "google", "mistral") */
+export function getProviderModels(catalog, providerId) {
+    const provider = catalog[providerId];
+    if (!provider)
+        return [];
+    return Object.values(provider.models);
+}
+/** Look up a specific model by ID across all providers */
+export function lookupModel(catalog, modelId) {
+    for (const provider of Object.values(catalog)) {
+        const model = provider.models[modelId];
+        if (model)
+            return model;
+    }
+    return undefined;
+}

package/dist/ai/provider.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Normalized types for provider abstraction.
+ * Mirrors Anthropic's format (since that's our primary provider)
+ * but decoupled from the SDK types.
+ */
+export interface TextBlock {
+    type: "text";
+    text: string;
+}
+export interface ToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: any;
+}
+export type NormalizedContentBlock = TextBlock | ToolUseBlock;
+export interface NormalizedResponse {
+    content: NormalizedContentBlock[];
+    stopReason: string;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export interface NormalizedMessage {
+    role: "user" | "assistant";
+    content: string | NormalizedContentBlock[] | NormalizedToolResult[];
+}
+export interface NormalizedToolResult {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, any>;
+        required: string[];
+    };
+}
+export interface SendMessageParams {
+    model: string;
+    system: string;
+    messages: NormalizedMessage[];
+    tools: ToolDefinition[];
+    maxTokens: number;
+    thinking?: {
+        type: "enabled";
+        budget_tokens: number;
+    };
+}
+export interface Provider {
+    name: string;
+    supportsThinking: boolean;
+    sendMessage(params: SendMessageParams): Promise<NormalizedResponse>;
+}

package/dist/ai/provider.js

@@ -0,0 +1,6 @@
+/**
+ * Normalized types for provider abstraction.
+ * Mirrors Anthropic's format (since that's our primary provider)
+ * but decoupled from the SDK types.
+ */
+export {};

package/dist/ai/providers/anthropic.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "../provider.js";
+export declare function createAnthropicProvider(opts: {
+    apiKey: string;
+    baseURL?: string;
+}): Provider;

package/dist/ai/providers/anthropic.js

@@ -0,0 +1,47 @@
+import Anthropic from "@anthropic-ai/sdk";
+export function createAnthropicProvider(opts) {
+    const client = new Anthropic(opts.baseURL
+        ? { apiKey: opts.apiKey, baseURL: opts.baseURL }
+        : { apiKey: opts.apiKey });
+    return {
+        name: "anthropic",
+        supportsThinking: true,
+        async sendMessage(params) {
+            const apiParams = {
+                model: params.model,
+                max_tokens: params.maxTokens,
+                system: params.system,
+                tools: params.tools,
+                messages: params.messages,
+            };
+            if (params.thinking) {
+                apiParams.thinking = params.thinking;
+            }
+            const response = await client.messages.create(apiParams);
+            // Filter thinking blocks and normalize content
+            const content = [];
+            for (const block of response.content) {
+                if (block.type === "thinking")
+                    continue;
+                if (block.type === "text") {
+                    content.push({ type: "text", text: block.text });
+                }
+                else if (block.type === "tool_use") {
+                    content.push({
+                        type: "tool_use",
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    });
+                }
+            }
+            return {
+                content,
+                stopReason: response.stop_reason || "end_turn",
+                usage: response.usage
+                    ? { input_tokens: response.usage.input_tokens, output_tokens: response.usage.output_tokens }
+                    : undefined,
+            };
+        },
+    };
+}

package/dist/ai/providers/index.d.ts

@@ -0,0 +1,2 @@
+import type { Provider } from "../provider.js";
+export declare function createProvider(): Provider;

package/dist/ai/providers/index.js

@@ -0,0 +1,20 @@
+import { config, useManaged, RAY_PROXY_BASE } from "../../config.js";
+import { createAnthropicProvider } from "./anthropic.js";
+import { createOpenAICompatibleProvider } from "./openai-compat.js";
+export function createProvider() {
+    if (useManaged()) {
+        return createAnthropicProvider({
+            apiKey: config.rayApiKey,
+            baseURL: `${RAY_PROXY_BASE}/ai`,
+        });
+    }
+    if (config.providerType === "openai-compatible") {
+        return createOpenAICompatibleProvider({
+            apiKey: config.openaiCompatibleKey,
+            baseURL: config.openaiCompatibleBaseURL,
+        });
+    }
+    return createAnthropicProvider({
+        apiKey: config.anthropicKey,
+    });
+}

package/dist/ai/providers/openai-compat.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "../provider.js";
+export declare function createOpenAICompatibleProvider(opts: {
+    apiKey: string;
+    baseURL: string;
+}): Provider;