@veroq/ai 1.0.0

package/dist/index.js

@@ -0,0 +1,911 @@
+// src/tools/veroq-search.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { PolarisClient } from "polaris-news-api";
+var veroqSearch = (options = {}) => tool({
+  description: "Search verified intelligence briefs with confidence scores and bias ratings across 18 verticals.",
+  parameters: z.object({
+    query: z.string().describe("The search query"),
+    category: z.string().optional().describe("Category slug (e.g. ai_ml, markets, crypto)"),
+    depth: z.enum(["fast", "standard", "deep"]).optional().describe("Speed tier: fast skips extras, deep adds entity cross-refs"),
+    limit: z.number().optional().describe("Max results to return (default 10)")
+  }),
+  execute: async ({ query, category, depth, limit }) => {
+    const client = new PolarisClient({ apiKey: options.apiKey });
+    return client.search(query, { category, depth, perPage: limit });
+  }
+});
+
+// src/tools/veroq-feed.ts
+import { tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+import { PolarisClient as PolarisClient2 } from "polaris-news-api";
+var veroqFeed = (options = {}) => tool2({
+  description: "Get the latest verified intelligence briefs from the VEROQ knowledge feed, optionally filtered by category.",
+  parameters: z2.object({
+    category: z2.string().optional().describe("Category slug to filter by (e.g. technology, markets)"),
+    limit: z2.number().optional().describe("Max briefs to return (default 20)")
+  }),
+  execute: async ({ category, limit }) => {
+    const client = new PolarisClient2({ apiKey: options.apiKey });
+    return client.agentFeed({ category, limit });
+  }
+});
+
+// src/tools/veroq-brief.ts
+import { tool as tool3 } from "ai";
+import { z as z3 } from "zod";
+import { PolarisClient as PolarisClient3 } from "polaris-news-api";
+var veroqBrief = (options = {}) => tool3({
+  description: "Get a specific verified news brief by ID with full analysis, sources, and counter-arguments.",
+  parameters: z3.object({
+    id: z3.string().describe("The brief ID to retrieve")
+  }),
+  execute: async ({ id }) => {
+    const client = new PolarisClient3({ apiKey: options.apiKey });
+    return client.brief(id);
+  }
+});
+
+// src/tools/veroq-extract.ts
+import { tool as tool4 } from "ai";
+import { z as z4 } from "zod";
+import { PolarisClient as PolarisClient4 } from "polaris-news-api";
+var veroqExtract = (options = {}) => tool4({
+  description: "Extract clean article content from URLs. Returns structured text with metadata.",
+  parameters: z4.object({
+    urls: z4.array(z4.string()).min(1).max(5).describe("URLs to extract article content from (1-5)")
+  }),
+  execute: async ({ urls }) => {
+    const client = new PolarisClient4({ apiKey: options.apiKey });
+    return client.extract(urls);
+  }
+});
+
+// src/tools/veroq-entities.ts
+import { tool as tool5 } from "ai";
+import { z as z5 } from "zod";
+import { PolarisClient as PolarisClient5 } from "polaris-news-api";
+var veroqEntities = (options = {}) => tool5({
+  description: "Look up news coverage for a specific entity (company, person, technology).",
+  parameters: z5.object({
+    name: z5.string().describe(
+      "Entity name to look up (e.g. OpenAI, Elon Musk, quantum computing)"
+    )
+  }),
+  execute: async ({ name }) => {
+    const client = new PolarisClient5({ apiKey: options.apiKey });
+    return client.entityBriefs(name);
+  }
+});
+
+// src/tools/veroq-trending.ts
+import { tool as tool6 } from "ai";
+import { z as z6 } from "zod";
+import { PolarisClient as PolarisClient6 } from "polaris-news-api";
+var veroqTrending = (options = {}) => tool6({
+  description: "Get trending entities across the news \u2014 the people, companies, and topics generating the most coverage right now.",
+  parameters: z6.object({
+    limit: z6.number().optional().describe("Max entities to return (default 10)")
+  }),
+  execute: async ({ limit }) => {
+    const client = new PolarisClient6({ apiKey: options.apiKey });
+    return client.trendingEntities(limit);
+  }
+});
+
+// src/tools/veroq-compare.ts
+import { tool as tool7 } from "ai";
+import { z as z7 } from "zod";
+import { PolarisClient as PolarisClient7 } from "polaris-news-api";
+var veroqCompare = (options = {}) => tool7({
+  description: "Compare how different news outlets covered the same story. Shows framing, bias, and what each side emphasizes or omits.",
+  parameters: z7.object({
+    briefId: z7.string().describe("The brief ID to compare source coverage for")
+  }),
+  execute: async ({ briefId }) => {
+    const client = new PolarisClient7({ apiKey: options.apiKey });
+    return client.compareSources(briefId);
+  }
+});
+
+// src/tools/veroq-research.ts
+import { tool as tool8 } from "ai";
+import { z as z8 } from "zod";
+import { PolarisClient as PolarisClient8 } from "polaris-news-api";
+var veroqResearch = (options = {}) => tool8({
+  description: "Deep research across verified intelligence briefs. Synthesizes a comprehensive report with key findings and information gaps. Costs 5 API credits.",
+  parameters: z8.object({
+    query: z8.string().describe("Research query to investigate"),
+    category: z8.string().optional().describe("Category slug to focus research (e.g. ai_ml, policy)"),
+    maxSources: z8.number().optional().describe("Maximum briefs to analyze (1-50, default 20)")
+  }),
+  execute: async ({ query, category, maxSources }) => {
+    const client = new PolarisClient8({ apiKey: options.apiKey });
+    return client.research(query, { category, maxSources });
+  }
+});
+
+// src/tools/veroq-verify.ts
+import { tool as tool9 } from "ai";
+import { z as z9 } from "zod";
+import { PolarisClient as PolarisClient9 } from "polaris-news-api";
+var veroqVerify = (options = {}) => tool9({
+  description: "Fact-check a claim against the VEROQ brief corpus. Returns a verdict (supported/contradicted/partially_supported/unverifiable) with confidence, sources, and nuances.",
+  parameters: z9.object({
+    claim: z9.string().min(10).max(1e3).describe("The claim to fact-check"),
+    context: z9.string().optional().describe("Category to narrow the search (e.g. 'tech', 'policy')")
+  }),
+  execute: async ({ claim, context }) => {
+    const client = new PolarisClient9({ apiKey: options.apiKey });
+    return client.verify(claim, { context });
+  }
+});
+
+// src/tools/veroq-timeline.ts
+import { tool as tool10 } from "ai";
+import { z as z10 } from "zod";
+import { PolarisClient as PolarisClient10 } from "polaris-news-api";
+var veroqTimeline = (options = {}) => tool10({
+  description: "Get the story evolution timeline for a living brief \u2014 shows how coverage developed over time with versioned updates, confidence changes, and new sources.",
+  parameters: z10.object({
+    briefId: z10.string().describe("Brief ID")
+  }),
+  execute: async ({ briefId }) => {
+    const client = new PolarisClient10({ apiKey: options.apiKey });
+    return client.timeline(briefId);
+  }
+});
+
+// src/tools/veroq-forecast.ts
+import { tool as tool11 } from "ai";
+import { z as z11 } from "zod";
+import { PolarisClient as PolarisClient11 } from "polaris-news-api";
+var veroqForecast = (options = {}) => tool11({
+  description: "Generate a forward-looking forecast for a topic based on current intelligence trends, momentum signals, and historical patterns.",
+  parameters: z11.object({
+    topic: z11.string().describe("Topic to forecast future developments for"),
+    depth: z11.enum(["fast", "standard", "deep"]).optional().describe("Analysis depth")
+  }),
+  execute: async ({ topic, depth }) => {
+    const client = new PolarisClient11({ apiKey: options.apiKey });
+    return client.forecast(topic, { depth });
+  }
+});
+
+// src/tools/veroq-contradictions.ts
+import { tool as tool12 } from "ai";
+import { z as z12 } from "zod";
+import { PolarisClient as PolarisClient12 } from "polaris-news-api";
+var veroqContradictions = (options = {}) => tool12({
+  description: "Find contradictions across the intelligence brief network \u2014 stories where sources disagree on facts, framing, or conclusions.",
+  parameters: z12.object({
+    severity: z12.string().optional().describe("Filter by severity level (e.g. high, medium, low)")
+  }),
+  execute: async ({ severity }) => {
+    const client = new PolarisClient12({ apiKey: options.apiKey });
+    return client.contradictions({ severity });
+  }
+});
+
+// src/tools/veroq-events.ts
+import { tool as tool13 } from "ai";
+import { z as z13 } from "zod";
+import { PolarisClient as PolarisClient13 } from "polaris-news-api";
+var veroqEvents = (options = {}) => tool13({
+  description: "Get notable events detected across intelligence briefs \u2014 significant developments, announcements, and inflection points.",
+  parameters: z13.object({
+    type: z13.string().optional().describe("Event type to filter by"),
+    subject: z13.string().optional().describe("Subject or entity to filter events for")
+  }),
+  execute: async ({ type, subject }) => {
+    const client = new PolarisClient13({ apiKey: options.apiKey });
+    return client.events({ type, subject });
+  }
+});
+
+// src/tools/veroq-web-search.ts
+import { tool as tool14 } from "ai";
+import { z as z14 } from "zod";
+import { PolarisClient as PolarisClient14 } from "polaris-news-api";
+var veroqWebSearch = (options = {}) => tool14({
+  description: "Search the web with optional VEROQ trust scoring. Returns web results with relevance and optional verification.",
+  parameters: z14.object({
+    query: z14.string().describe("Web search query"),
+    limit: z14.number().optional().describe("Max results to return (default 5)"),
+    freshness: z14.string().optional().describe("Freshness filter (e.g. 'day', 'week', 'month')"),
+    region: z14.string().optional().describe("Region code (e.g. 'us', 'eu')"),
+    verify: z14.boolean().optional().describe("Enable VEROQ trust scoring on results")
+  }),
+  execute: async ({ query, limit, freshness, region, verify }) => {
+    const client = new PolarisClient14({ apiKey: options.apiKey });
+    return client.webSearch(query, { limit, freshness, region, verify });
+  }
+});
+
+// src/tools/veroq-crawl.ts
+import { tool as tool15 } from "ai";
+import { z as z15 } from "zod";
+import { PolarisClient as PolarisClient15 } from "polaris-news-api";
+var veroqCrawl = (options = {}) => tool15({
+  description: "Extract structured content from a URL with optional link following. Returns page content, metadata, and optionally discovered links.",
+  parameters: z15.object({
+    url: z15.string().url().describe("URL to crawl and extract content from"),
+    depth: z15.number().optional().describe("Crawl depth (default 1)"),
+    max_pages: z15.number().optional().describe("Max pages to crawl (default 5)"),
+    include_links: z15.boolean().optional().describe("Include extracted links in response")
+  }),
+  execute: async ({ url, depth, max_pages, include_links }) => {
+    const client = new PolarisClient15({ apiKey: options.apiKey });
+    return client.crawl(url, { depth, max_pages, include_links });
+  }
+});
+
+// src/tools/veroq-ticker-resolve.ts
+import { tool as tool16 } from "ai";
+import { z as z16 } from "zod";
+import { PolarisClient as PolarisClient16 } from "polaris-news-api";
+var veroqTickerResolve = (options = {}) => tool16({
+  description: "Resolve ticker symbols to company names and sectors. Pass one or more comma-separated symbols to validate them against the VEROQ knowledge base.",
+  parameters: z16.object({
+    q: z16.string().describe(
+      "Comma-separated ticker symbols to resolve (e.g. AAPL,MSFT,TSLA)"
+    )
+  }),
+  execute: async ({ q }) => {
+    const client = new PolarisClient16({ apiKey: options.apiKey });
+    const symbols = q.split(",").map((s) => s.trim());
+    return client.tickerResolve(symbols);
+  }
+});
+
+// src/tools/veroq-ticker.ts
+import { tool as tool17 } from "ai";
+import { z as z17 } from "zod";
+import { PolarisClient as PolarisClient17 } from "polaris-news-api";
+var veroqTicker = (options = {}) => tool17({
+  description: "Look up a single ticker symbol to get its brief count, sentiment, sector, and last mention timestamp.",
+  parameters: z17.object({
+    symbol: z17.string().describe("Ticker symbol to look up (e.g. AAPL)")
+  }),
+  execute: async ({ symbol }) => {
+    const client = new PolarisClient17({ apiKey: options.apiKey });
+    return client.ticker(symbol);
+  }
+});
+
+// src/tools/veroq-ticker-history.ts
+import { tool as tool18 } from "ai";
+import { z as z18 } from "zod";
+import { PolarisClient as PolarisClient18 } from "polaris-news-api";
+var veroqTickerHistory = (options = {}) => tool18({
+  description: "Get daily sentiment timeseries for a ticker symbol \u2014 tracks how news sentiment has changed over time.",
+  parameters: z18.object({
+    symbol: z18.string().describe("Ticker symbol (e.g. AAPL)"),
+    days: z18.number().optional().describe("Number of days of history to return (default 30)")
+  }),
+  execute: async ({ symbol, days }) => {
+    const client = new PolarisClient18({ apiKey: options.apiKey });
+    return client.tickerHistory(symbol, { days });
+  }
+});
+
+// src/tools/veroq-ticker-score.ts
+import { tool as tool19 } from "ai";
+import { z as z19 } from "zod";
+import { PolarisClient as PolarisClient19 } from "polaris-news-api";
+var veroqTickerScore = (options = {}) => tool19({
+  description: "Get a composite trading signal score for a ticker, combining sentiment, momentum, volume, and other intelligence signals into a single score.",
+  parameters: z19.object({
+    symbol: z19.string().describe("Ticker symbol to score (e.g. AAPL)")
+  }),
+  execute: async ({ symbol }) => {
+    const client = new PolarisClient19({ apiKey: options.apiKey });
+    return client.tickerScore(symbol);
+  }
+});
+
+// src/tools/veroq-sectors.ts
+import { tool as tool20 } from "ai";
+import { z as z20 } from "zod";
+import { PolarisClient as PolarisClient20 } from "polaris-news-api";
+var veroqSectors = (options = {}) => tool20({
+  description: "Get all market sectors with sentiment overview \u2014 shows which sectors are trending positive or negative based on intelligence coverage.",
+  parameters: z20.object({
+    days: z20.number().optional().describe("Lookback window in days (default 7)")
+  }),
+  execute: async ({ days }) => {
+    const client = new PolarisClient20({ apiKey: options.apiKey });
+    return client.sectors({ days });
+  }
+});
+
+// src/tools/veroq-portfolio-feed.ts
+import { tool as tool21 } from "ai";
+import { z as z21 } from "zod";
+import { PolarisClient as PolarisClient21 } from "polaris-news-api";
+var veroqPortfolioFeed = (options = {}) => tool21({
+  description: "Pass portfolio holdings (tickers + weights) and get ranked intelligence briefs relevant to your positions.",
+  parameters: z21.object({
+    holdings: z21.array(
+      z21.object({
+        ticker: z21.string().describe("Ticker symbol (e.g. AAPL)"),
+        weight: z21.number().describe("Portfolio weight as a decimal (e.g. 0.25 for 25%)")
+      })
+    ).min(1).describe("Array of portfolio holdings with ticker and weight"),
+    days: z21.number().optional().describe("Lookback window in days (default 7)"),
+    limit: z21.number().optional().describe("Max briefs to return (default 20)")
+  }),
+  execute: async ({ holdings, days, limit }) => {
+    const client = new PolarisClient21({ apiKey: options.apiKey });
+    return client.portfolioFeed(holdings, { days, limit });
+  }
+});
+
+// src/tools/veroq-events-calendar.ts
+import { tool as tool22 } from "ai";
+import { z as z22 } from "zod";
+import { PolarisClient as PolarisClient22 } from "polaris-news-api";
+var veroqEventsCalendar = (options = {}) => tool22({
+  description: "Get structured market events (earnings, launches, regulatory deadlines, etc.) filterable by ticker and event type.",
+  parameters: z22.object({
+    ticker: z22.string().optional().describe("Filter events for a specific ticker symbol"),
+    type: z22.string().optional().describe("Filter by event type (e.g. earnings, launch, regulatory)"),
+    days: z22.number().optional().describe("Lookback/lookahead window in days (default 30)"),
+    limit: z22.number().optional().describe("Max events to return (default 30)")
+  }),
+  execute: async ({ ticker, type, days, limit }) => {
+    const client = new PolarisClient22({ apiKey: options.apiKey });
+    return client.eventsCalendar({ ticker, type, days, limit });
+  }
+});
+
+// src/tools/veroq-candles.ts
+import { tool as tool23 } from "ai";
+import { z as z23 } from "zod";
+
+// src/tools/_fetch.ts
+var DEFAULT_BASE_URL = "https://api.thepolarisreport.com";
+async function veroqGet(options, path, params) {
+  const base = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const qs = new URLSearchParams();
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0) qs.set(k, v);
+    }
+  }
+  const qsStr = qs.toString();
+  const url = `${base}${path}${qsStr ? `?${qsStr}` : ""}`;
+  const headers = { "Content-Type": "application/json" };
+  if (options.apiKey) headers["Authorization"] = `Bearer ${options.apiKey}`;
+  const res = await fetch(url, { headers });
+  if (!res.ok) throw new Error(`VEROQ API error ${res.status}`);
+  return res.json();
+}
+async function veroqPost(options, path, body) {
+  const base = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const url = `${base}${path}`;
+  const headers = { "Content-Type": "application/json" };
+  if (options.apiKey) headers["Authorization"] = `Bearer ${options.apiKey}`;
+  const res = await fetch(url, { method: "POST", headers, body: JSON.stringify(body) });
+  if (!res.ok) throw new Error(`VEROQ API error ${res.status}`);
+  return res.json();
+}
+
+// src/tools/veroq-candles.ts
+var veroqCandles = (options = {}) => tool23({
+  description: "Get OHLCV candlestick data for a ticker symbol. Returns date, open, high, low, close, and volume for each period.",
+  parameters: z23.object({
+    symbol: z23.string().describe("Ticker symbol (e.g. AAPL, MSFT)"),
+    interval: z23.enum(["1d", "1wk", "1mo"]).optional().describe("Candle interval (default 1d)"),
+    range: z23.enum(["1mo", "3mo", "6mo", "1y", "2y", "5y"]).optional().describe("Date range (default 6mo)")
+  }),
+  execute: async ({ symbol, interval, range }) => {
+    return veroqGet(options, `/api/v1/ticker/${encodeURIComponent(symbol)}/candles`, {
+      interval,
+      range
+    });
+  }
+});
+
+// src/tools/veroq-technicals.ts
+import { tool as tool24 } from "ai";
+import { z as z24 } from "zod";
+var veroqTechnicals = (options = {}) => tool24({
+  description: "Get all technical indicators and a signal summary for a ticker. Includes SMA, EMA, RSI, MACD, Bollinger Bands, ATR, Stochastic, ADX, OBV, and VWAP with an overall buy/sell/neutral verdict.",
+  parameters: z24.object({
+    symbol: z24.string().describe("Ticker symbol (e.g. NVDA)"),
+    range: z24.enum(["1mo", "3mo", "6mo", "1y", "2y", "5y"]).optional().describe("Date range for indicator calculation (default 6mo)")
+  }),
+  execute: async ({ symbol, range }) => {
+    return veroqGet(options, `/api/v1/ticker/${encodeURIComponent(symbol)}/technicals`, {
+      range
+    });
+  }
+});
+
+// src/tools/veroq-market-movers.ts
+import { tool as tool25 } from "ai";
+import { z as z25 } from "zod";
+var veroqMarketMovers = (options = {}) => tool25({
+  description: "Get top market movers \u2014 gainers, losers, and most active stocks by volume. Useful for a quick snapshot of what is moving in the market right now.",
+  parameters: z25.object({}),
+  execute: async () => {
+    return veroqGet(options, "/api/v1/market/movers");
+  }
+});
+
+// src/tools/veroq-economy.ts
+import { tool as tool26 } from "ai";
+import { z as z26 } from "zod";
+var veroqEconomy = (options = {}) => tool26({
+  description: "Get economic indicators from the FRED API. Without an indicator slug, returns a summary of all key indicators (GDP, CPI, unemployment, etc.). With a slug, returns that indicator's history.",
+  parameters: z26.object({
+    indicator: z26.string().optional().describe("Indicator slug (e.g. gdp, cpi, unemployment, fed_funds). Omit for summary of all."),
+    limit: z26.number().optional().describe("Number of historical observations to return (default 30, max 100)")
+  }),
+  execute: async ({ indicator, limit }) => {
+    const path = indicator ? `/api/v1/economy/${encodeURIComponent(indicator)}` : "/api/v1/economy";
+    return veroqGet(options, path, {
+      limit: limit !== void 0 ? String(limit) : void 0
+    });
+  }
+});
+
+// src/tools/veroq-forex.ts
+import { tool as tool27 } from "ai";
+import { z as z27 } from "zod";
+var veroqForex = (options = {}) => tool27({
+  description: "Get forex exchange rates. Without a pair, returns all major forex pairs. With a pair (e.g. EURUSD), returns that specific rate and change data.",
+  parameters: z27.object({
+    pair: z27.string().optional().describe("Forex pair (e.g. EURUSD, GBPUSD, USDJPY). Omit for all pairs.")
+  }),
+  execute: async ({ pair }) => {
+    const path = pair ? `/api/v1/forex/${encodeURIComponent(pair.toUpperCase())}` : "/api/v1/forex";
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-commodities.ts
+import { tool as tool28 } from "ai";
+import { z as z28 } from "zod";
+var veroqCommodities = (options = {}) => tool28({
+  description: "Get commodity prices. Without a symbol, returns all tracked commodities (gold, oil, silver, etc.). With a symbol, returns that commodity's current price and change data.",
+  parameters: z28.object({
+    symbol: z28.string().optional().describe("Commodity slug (e.g. gold, oil, silver, natural_gas). Omit for all.")
+  }),
+  execute: async ({ symbol }) => {
+    const path = symbol ? `/api/v1/commodities/${encodeURIComponent(symbol.toLowerCase())}` : "/api/v1/commodities";
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-crypto.ts
+import { tool as tool29 } from "ai";
+import { z as z29 } from "zod";
+var veroqCrypto = (options = {}) => tool29({
+  description: "Get crypto market data. Without a symbol, returns market overview (total market cap, BTC dominance, etc.). With a symbol (e.g. BTC, ETH, SOL), returns that token's price, volume, and metadata.",
+  parameters: z29.object({
+    symbol: z29.string().optional().describe("Crypto symbol (e.g. BTC, ETH, SOL). Omit for market overview.")
+  }),
+  execute: async ({ symbol }) => {
+    const path = symbol ? `/api/v1/crypto/${encodeURIComponent(symbol.toUpperCase())}` : "/api/v1/crypto";
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-crypto-defi.ts
+import { tool as tool30 } from "ai";
+import { z as z30 } from "zod";
+var veroqCryptoDefi = (options = {}) => tool30({
+  description: "Get DeFi (decentralized finance) data. Without a protocol, returns TVL overview with top protocols and chain breakdown. With a protocol slug (e.g. aave, uniswap), returns that protocol's TVL history and details.",
+  parameters: z30.object({
+    protocol: z30.string().optional().describe("DeFi protocol slug (e.g. aave, uniswap, lido). Omit for overview.")
+  }),
+  execute: async ({ protocol }) => {
+    const path = protocol ? `/api/v1/crypto/defi/${encodeURIComponent(protocol.toLowerCase())}` : "/api/v1/crypto/defi";
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-backtest.ts
+import { tool as tool31 } from "ai";
+import { z as z31 } from "zod";
+import { PolarisClient as PolarisClient23 } from "polaris-news-api";
+var veroqBacktest = (options = {}) => tool31({
+  description: "Backtest a news-driven trading strategy. Define entry/exit filters based on sentiment, RSI, and other signals, then see historical performance including return, drawdown, Sharpe ratio, and win rate.",
+  parameters: z31.object({
+    strategy: z31.object({
+      entry_filters: z31.record(z31.unknown()).describe("Entry signal filters (e.g. { rsi_below: 30, sentiment_above: 0.3 })"),
+      exit_filters: z31.record(z31.unknown()).describe("Exit signal filters (e.g. { rsi_above: 50 })"),
+      asset_type: z31.string().optional().describe("Asset type filter (e.g. equity, crypto)"),
+      sector: z31.string().optional().describe("Sector filter (e.g. Semiconductors, Technology)")
+    }).describe("Strategy definition with entry/exit filters"),
+    period: z31.string().optional().describe("Backtest period (e.g. 1y, 6mo, 3mo). Default: 1y")
+  }),
+  execute: async ({ strategy, period }) => {
+    const client = new PolarisClient23({ apiKey: options.apiKey });
+    return client.backtest(strategy, { period: period ?? "1y" });
+  }
+});
+
+// src/tools/veroq-correlation.ts
+import { tool as tool32 } from "ai";
+import { z as z32 } from "zod";
+import { PolarisClient as PolarisClient24 } from "polaris-news-api";
+var veroqCorrelation = (options = {}) => tool32({
+  description: "Get a news-sentiment correlation matrix for multiple tickers. Shows how closely related their coverage patterns and sentiment movements are over a given period.",
+  parameters: z32.object({
+    tickers: z32.array(z32.string()).min(2).describe("Array of ticker symbols to correlate (e.g. ['NVDA', 'AMD', 'INTC'])"),
+    days: z32.number().optional().describe("Lookback period in days (default 30)")
+  }),
+  execute: async ({ tickers, days }) => {
+    const client = new PolarisClient24({ apiKey: options.apiKey });
+    return client.correlation(tickers, { days: days ?? 30 });
+  }
+});
+
+// src/tools/veroq-screener.ts
+import { tool as tool33 } from "ai";
+import { z as z33 } from "zod";
+import { PolarisClient as PolarisClient25 } from "polaris-news-api";
+var veroqScreener = (options = {}) => tool33({
+  description: "Screen stocks using natural language. Describe what you're looking for (e.g. 'oversold tech stocks with upcoming earnings') and get matching tickers with scores.",
+  parameters: z33.object({
+    query: z33.string().describe("Natural language screening query"),
+    limit: z33.number().optional().describe("Max results to return (default 20)")
+  }),
+  execute: async ({ query, limit }) => {
+    const client = new PolarisClient25({ apiKey: options.apiKey });
+    return client.screenerNatural(query, { limit });
+  }
+});
+
+// src/tools/veroq-news-impact.ts
+import { tool as tool34 } from "ai";
+import { z as z34 } from "zod";
+import { PolarisClient as PolarisClient26 } from "polaris-news-api";
+var veroqNewsImpact = (options = {}) => tool34({
+  description: "Analyze the impact of news coverage on a ticker's price and sentiment. Shows how recent news events correlated with price movements.",
+  parameters: z34.object({
+    symbol: z34.string().describe("Ticker symbol to analyze (e.g. NVDA)")
+  }),
+  execute: async ({ symbol }) => {
+    const client = new PolarisClient26({ apiKey: options.apiKey });
+    return client.newsImpact(symbol);
+  }
+});
+
+// src/tools/veroq-competitors.ts
+import { tool as tool35 } from "ai";
+import { z as z35 } from "zod";
+import { PolarisClient as PolarisClient27 } from "polaris-news-api";
+var veroqCompetitors = (options = {}) => tool35({
+  description: "Get the competitive landscape for a ticker. Returns competitors with comparative sentiment, coverage volume, and sector positioning.",
+  parameters: z35.object({
+    symbol: z35.string().describe("Ticker symbol to get competitors for (e.g. NVDA)")
+  }),
+  execute: async ({ symbol }) => {
+    const client = new PolarisClient27({ apiKey: options.apiKey });
+    return client.competitors(symbol);
+  }
+});
+
+// src/tools/veroq-social-sentiment.ts
+import { tool as tool36 } from "ai";
+import { z as z36 } from "zod";
+var veroqSocialSentiment = (options = {}) => tool36({
+  description: "Get social media sentiment for a ticker symbol \u2014 tracks mentions, sentiment scores, and trending status across social platforms.",
+  parameters: z36.object({
+    symbol: z36.string().describe("Ticker symbol to look up (e.g. AAPL)")
+  }),
+  execute: async ({ symbol }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(symbol.toUpperCase())}/social`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-social-trending.ts
+import { tool as tool37 } from "ai";
+import { z as z37 } from "zod";
+var veroqSocialTrending = (options = {}) => tool37({
+  description: "Get trending tickers on social media \u2014 shows which stocks and crypto are generating the most buzz across social platforms right now.",
+  parameters: z37.object({
+    limit: z37.number().optional().describe("Max results to return (default 20)")
+  }),
+  execute: async ({ limit }) => {
+    return veroqGet(options, "/api/v1/social/trending", {
+      limit: limit !== void 0 ? String(limit) : void 0
+    });
+  }
+});
+
+// src/tools/veroq-ipo-calendar.ts
+import { tool as tool38 } from "ai";
+import { z as z38 } from "zod";
+var veroqIpoCalendar = (options = {}) => tool38({
+  description: "Get upcoming IPOs \u2014 lists companies preparing to go public with expected dates, price ranges, and exchange listings.",
+  parameters: z38.object({
+    limit: z38.number().optional().describe("Max results to return (default 20)")
+  }),
+  execute: async ({ limit }) => {
+    return veroqGet(options, "/api/v1/ipo/calendar", {
+      limit: limit !== void 0 ? String(limit) : void 0
+    });
+  }
+});
+
+// src/tools/veroq-ticker-news.ts
+import { tool as tool39 } from "ai";
+import { z as z39 } from "zod";
+var veroqTickerNews = (options = {}) => tool39({
+  description: "Get recent news articles for a specific ticker symbol \u2014 returns headlines, sources, timestamps, and sentiment for each article.",
+  parameters: z39.object({
+    symbol: z39.string().describe("Ticker symbol to get news for (e.g. AAPL)"),
+    limit: z39.number().optional().describe("Max articles to return (default 20)")
+  }),
+  execute: async ({ symbol, limit }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(symbol.toUpperCase())}/news`;
+    return veroqGet(options, path, {
+      limit: limit !== void 0 ? String(limit) : void 0
+    });
+  }
+});
+
+// src/tools/veroq-ticker-analysis.ts
+import { tool as tool40 } from "ai";
+import { z as z40 } from "zod";
+var veroqTickerAnalysis = (options = {}) => tool40({
+  description: "Get a full analysis for a ticker symbol \u2014 includes sentiment breakdown, technical signals, news summary, and an overall outlook.",
+  parameters: z40.object({
+    symbol: z40.string().describe("Ticker symbol to analyze (e.g. NVDA)")
+  }),
+  execute: async ({ symbol }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(symbol.toUpperCase())}/analysis`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-search-suggest.ts
+import { tool as tool41 } from "ai";
+import { z as z41 } from "zod";
+var veroqSearchSuggest = (options = {}) => tool41({
+  description: "Get search autocomplete suggestions \u2014 returns matching topics, tickers, and entities as the user types a query.",
+  parameters: z41.object({
+    q: z41.string().describe("Partial search query to get suggestions for")
+  }),
+  execute: async ({ q }) => {
+    return veroqGet(options, "/api/v1/search/suggest", { q });
+  }
+});
+
+// src/tools/veroq-defi-protocol.ts
+import { tool as tool42 } from "ai";
+import { z as z42 } from "zod";
+var veroqDefiProtocol = (options = {}) => tool42({
+  description: "Get detailed data for a specific DeFi protocol \u2014 includes TVL history, chain breakdown, token info, and protocol metrics.",
+  parameters: z42.object({
+    protocol: z42.string().describe("DeFi protocol slug (e.g. aave, uniswap, lido)")
+  }),
+  execute: async ({ protocol }) => {
+    const path = `/api/v1/crypto/defi/${encodeURIComponent(protocol.toLowerCase())}`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-economy-indicator.ts
+import { tool as tool43 } from "ai";
+import { z as z43 } from "zod";
+var veroqEconomyIndicator = (options = {}) => tool43({
+  description: "Get data for a specific economic indicator \u2014 returns historical observations, current value, and trend for indicators like GDP, CPI, unemployment, and fed funds rate.",
+  parameters: z43.object({
+    indicator: z43.string().describe("Economic indicator slug (e.g. gdp, cpi, unemployment, fed_funds)"),
+    limit: z43.number().optional().describe("Number of historical observations to return (default 30, max 100)")
+  }),
+  execute: async ({ indicator, limit }) => {
+    const path = `/api/v1/economy/${encodeURIComponent(indicator)}`;
+    return veroqGet(options, path, {
+      limit: limit !== void 0 ? String(limit) : void 0
+    });
+  }
+});
+
+// src/tools/veroq-generate-report.ts
+import { tool as tool44 } from "ai";
+import { z as z44 } from "zod";
+import { PolarisClient as PolarisClient28 } from "polaris-news-api";
+var veroqGenerateReport = (options = {}) => tool44({
+  description: "Generate an AI-powered research report for a given ticker symbol. Returns a comprehensive analysis including fundamentals, technicals, and news sentiment.",
+  parameters: z44.object({
+    ticker: z44.string().describe("The ticker symbol to generate a report for (e.g. AAPL, BTC)"),
+    tier: z44.string().optional().describe("Report tier \u2014 'quick' for a fast summary or 'deep' for full analysis (default 'quick')")
+  }),
+  execute: async ({ ticker, tier }) => {
+    const client = new PolarisClient28({ apiKey: options.apiKey });
+    return client.generateReport(ticker, tier);
+  }
+});
+
+// src/tools/veroq-get-report.ts
+import { tool as tool45 } from "ai";
+import { z as z45 } from "zod";
+import { PolarisClient as PolarisClient29 } from "polaris-news-api";
+var veroqGetReport = (options = {}) => tool45({
+  description: "Retrieve a previously generated report by its ID. Returns the full report content including all analysis sections.",
+  parameters: z45.object({
+    reportId: z45.string().describe("The report ID to retrieve")
+  }),
+  execute: async ({ reportId }) => {
+    const client = new PolarisClient29({ apiKey: options.apiKey });
+    return client.getReport(reportId);
+  }
+});
+
+// src/tools/veroq-ask.ts
+import { tool as tool46 } from "ai";
+import { z as z46 } from "zod";
+var veroqAsk = (options = {}) => tool46({
+  description: "Ask any question about markets, companies, economics, or geopolitics and get an AI-generated answer grounded in verified intelligence briefs. The most versatile tool in the VEROQ toolkit.",
+  parameters: z46.object({
+    question: z46.string().describe("The question to ask (e.g. 'What is driving NVIDIA stock price this week?')")
+  }),
+  execute: async ({ question }) => {
+    return veroqPost(options, "/api/v1/ask", { question });
+  }
+});
+
+// src/tools/veroq-full.ts
+import { tool as tool47 } from "ai";
+import { z as z47 } from "zod";
+var veroqFull = (options = {}) => tool47({
+  description: "Get a comprehensive full profile for a ticker symbol \u2014 combines price, fundamentals, technicals, sentiment, news, and analyst data in a single call.",
+  parameters: z47.object({
+    ticker: z47.string().describe("Ticker symbol to look up (e.g. AAPL, BTC, ETH)")
+  }),
+  execute: async ({ ticker }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(ticker.toUpperCase())}/full`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-insider.ts
+import { tool as tool48 } from "ai";
+import { z as z48 } from "zod";
+var veroqInsider = (options = {}) => tool48({
+  description: "Get recent insider trading activity for a ticker symbol \u2014 shows buys, sells, and option exercises by company officers and directors.",
+  parameters: z48.object({
+    ticker: z48.string().describe("Ticker symbol to look up insider trades for (e.g. AAPL)")
+  }),
+  execute: async ({ ticker }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(ticker.toUpperCase())}/insider`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-filings.ts
+import { tool as tool49 } from "ai";
+import { z as z49 } from "zod";
+var veroqFilings = (options = {}) => tool49({
+  description: "Get recent SEC filings for a ticker symbol \u2014 includes 10-K, 10-Q, 8-K, and other regulatory filings with links and summaries.",
+  parameters: z49.object({
+    ticker: z49.string().describe("Ticker symbol to look up filings for (e.g. TSLA)")
+  }),
+  execute: async ({ ticker }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(ticker.toUpperCase())}/filings`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-analysts.ts
+import { tool as tool50 } from "ai";
+import { z as z50 } from "zod";
+var veroqAnalysts = (options = {}) => tool50({
+  description: "Get Wall Street analyst ratings and price targets for a ticker symbol \u2014 includes consensus rating, target prices, and recent upgrades/downgrades.",
+  parameters: z50.object({
+    ticker: z50.string().describe("Ticker symbol to look up analyst ratings for (e.g. MSFT)")
+  }),
+  execute: async ({ ticker }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(ticker.toUpperCase())}/analysts`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-congress.ts
+import { tool as tool51 } from "ai";
+import { z as z51 } from "zod";
+var veroqCongress = (options = {}) => tool51({
+  description: "Get recent stock trades disclosed by U.S. Congress members. Optionally filter by a specific ticker symbol.",
+  parameters: z51.object({
+    symbol: z51.string().optional().describe("Ticker symbol to filter trades (e.g. NVDA). Omit for all recent congressional trades.")
+  }),
+  execute: async ({ symbol }) => {
+    return veroqGet(options, "/api/v1/congress/trades", {
+      symbol: symbol ? symbol.toUpperCase() : void 0
+    });
+  }
+});
+
+// src/tools/veroq-institutions.ts
+import { tool as tool52 } from "ai";
+import { z as z52 } from "zod";
+var veroqInstitutions = (options = {}) => tool52({
+  description: "Get institutional ownership data for a ticker symbol \u2014 shows top holders, recent position changes, and ownership concentration.",
+  parameters: z52.object({
+    ticker: z52.string().describe("Ticker symbol to look up institutional ownership for (e.g. GOOG)")
+  }),
+  execute: async ({ ticker }) => {
+    const path = `/api/v1/ticker/${encodeURIComponent(ticker.toUpperCase())}/institutions`;
+    return veroqGet(options, path);
+  }
+});
+
+// src/tools/veroq-run-agent.ts
+import { tool as tool53 } from "ai";
+import { z as z53 } from "zod";
+var veroqRunAgent = (options = {}) => tool53({
+  description: "Run a VEROQ agent by its slug with custom inputs. Agents perform multi-step research, analysis, and reporting workflows.",
+  parameters: z53.object({
+    slug: z53.string().describe("The agent slug to run (e.g. 'earnings-analyzer', 'sector-report')"),
+    inputs: z53.record(z53.unknown()).describe("Key-value inputs to pass to the agent")
+  }),
+  execute: async ({ slug, inputs }) => {
+    const path = `/api/v1/agents/run/${encodeURIComponent(slug)}`;
+    return veroqPost(options, path, inputs);
+  }
+});
+export {
+  veroqAnalysts,
+  veroqAsk,
+  veroqBacktest,
+  veroqBrief,
+  veroqCandles,
+  veroqCommodities,
+  veroqCompare,
+  veroqCompetitors,
+  veroqCongress,
+  veroqContradictions,
+  veroqCorrelation,
+  veroqCrawl,
+  veroqCrypto,
+  veroqCryptoDefi,
+  veroqDefiProtocol,
+  veroqEconomy,
+  veroqEconomyIndicator,
+  veroqEntities,
+  veroqEvents,
+  veroqEventsCalendar,
+  veroqExtract,
+  veroqFeed,
+  veroqFilings,
+  veroqForecast,
+  veroqForex,
+  veroqFull,
+  veroqGenerateReport,
+  veroqGetReport,
+  veroqInsider,
+  veroqInstitutions,
+  veroqIpoCalendar,
+  veroqMarketMovers,
+  veroqNewsImpact,
+  veroqPortfolioFeed,
+  veroqResearch,
+  veroqRunAgent,
+  veroqScreener,
+  veroqSearch,
+  veroqSearchSuggest,
+  veroqSectors,
+  veroqSocialSentiment,
+  veroqSocialTrending,
+  veroqTechnicals,
+  veroqTicker,
+  veroqTickerAnalysis,
+  veroqTickerHistory,
+  veroqTickerNews,
+  veroqTickerResolve,
+  veroqTickerScore,
+  veroqTimeline,
+  veroqTrending,
+  veroqVerify,
+  veroqWebSearch
+};
+//# sourceMappingURL=index.js.map