opencandle 0.3.0 → 0.4.0

package/src/tools/sentiment/reddit-sentiment.ts

@@ -0,0 +1,164 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getSubredditPosts, getPostComments } from "../../providers/reddit.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import type { RedditSentimentResult } from "../../types/sentiment.js";
+import { RedditAdapter } from "../../sentiment/adapters/reddit.js";
+import { getSentimentPipeline } from "../../sentiment/index.js";
+import { getConfig } from "../../config.js";
+
+const params = Type.Object({
+  subreddit: Type.Optional(
+    Type.String({
+      description:
+        "Subreddit name (e.g. wallstreetbets, stocks). If omitted, searches across default subreddits.",
+    }),
+  ),
+  query: Type.Optional(
+    Type.String({
+      description:
+        "Topic or ticker to filter posts by (e.g. AAPL, bitcoin). Searches titles and post bodies.",
+    }),
+  ),
+  subreddits: Type.Optional(
+    Type.Array(Type.String(), {
+      description: "Multiple subreddits to search. Overrides single subreddit param.",
+    }),
+  ),
+  limit: Type.Optional(
+    Type.Number({ description: "Number of posts per subreddit. Default: 25, max: 100" }),
+  ),
+});
+
+export const redditSentimentTool: AgentTool<typeof params, RedditSentimentResult> = {
+  name: "get_reddit_sentiment",
+  label: "Reddit Sentiment",
+  description:
+    "Analyze sentiment from financial Reddit communities. Supports single subreddit, multi-subreddit, and topic filtering. Returns scored posts with comment analysis and trend context.",
+  parameters: params,
+  async execute(toolCallId, args) {
+    const limit = Math.min(args.limit ?? 25, 100);
+    const config = getConfig();
+
+    // Determine subreddits to search
+    let subreddits: string[];
+    if (args.subreddits && args.subreddits.length > 0) {
+      subreddits = args.subreddits;
+    } else if (args.subreddit) {
+      subreddits = [args.subreddit];
+    } else {
+      subreddits = config.sentiment?.defaultSubreddits ?? ["wallstreetbets", "stocks", "investing", "options"];
+    }
+
+    // Fetch from all subreddits
+    const allResults: RedditSentimentResult[] = [];
+    const warnings: string[] = [];
+    for (const sub of subreddits) {
+      const providerResult = await wrapProvider("reddit", () => getSubredditPosts(sub, limit));
+      if (providerResult.status === "unavailable") {
+        warnings.push(`r/${sub}: ${providerResult.reason}`);
+        continue;
+      }
+      allResults.push(providerResult.data);
+    }
+
+    if (allResults.length === 0) {
+      return {
+        content: [{ type: "text", text: `⚠ Reddit sentiment unavailable (${warnings.join("; ")}).` }],
+        details: null as any,
+      };
+    }
+
+    // Merge and filter by query if provided
+    const adapter = new RedditAdapter();
+    let allRecords = allResults.flatMap((r) => adapter.mapPostsToRecords(r, args.query ?? subreddits.join("+")));
+
+    // Topic filtering
+    if (args.query) {
+      const queryLower = args.query.toLowerCase();
+      allRecords = allRecords.filter((r) =>
+        r.text.toLowerCase().includes(queryLower) ||
+        (r.title?.toLowerCase().includes(queryLower) ?? false),
+      );
+    }
+
+    // Deduplicate by sourceId (crossposts)
+    const seen = new Set<string>();
+    allRecords = allRecords.filter((r) => {
+      if (seen.has(r.sourceId)) return false;
+      seen.add(r.sourceId);
+      return true;
+    });
+
+    // Fetch comments for top 10 posts by engagement
+    const commentsPerPost = config.sentiment?.commentsPerPost ?? 5;
+    const topPosts = [...allRecords]
+      .sort((a, b) => b.engagement.score - a.engagement.score)
+      .slice(0, 10);
+
+    for (const post of topPosts) {
+      const sub = (post.metadata.subreddit as string) ?? subreddits[0];
+      if ((post.engagement.replies ?? 0) === 0) continue;
+      try {
+        const comments = await getPostComments(sub, post.sourceId, commentsPerPost);
+        const commentRecords = adapter.mapCommentsToRecords(
+          comments,
+          post.sourceId,
+          sub,
+          args.query ?? subreddits.join("+"),
+        );
+        allRecords.push(...commentRecords);
+      } catch {
+        // Comment fetch failures are non-fatal
+      }
+    }
+
+    // Process through pipeline
+    const pipeline = getSentimentPipeline();
+    const pipelineResult = await pipeline.processRecords(allRecords, args.query ?? subreddits.join("+"));
+
+    // Build output using first result as base for backward compatibility
+    const firstResult = allResults[0];
+    const postRecords = pipelineResult.fresh.filter((r) => !r.metadata.isComment);
+    const commentRecords = pipelineResult.fresh.filter((r) => r.metadata.isComment);
+    const avgScore = postRecords.length > 0
+      ? postRecords.reduce((s, r) => s + r.sentiment.score, 0) / postRecords.length
+      : 0;
+
+    const sentimentLabel =
+      avgScore > 0.3 ? "Bullish" :
+      avgScore < -0.3 ? "Bearish" :
+      avgScore > 0 ? "Leaning Bullish" :
+      avgScore < 0 ? "Leaning Bearish" : "Neutral";
+
+    const subLabel = subreddits.length === 1 ? `r/${subreddits[0]}` : `${subreddits.length} subreddits`;
+    const lines = [
+      `**Reddit: ${args.query ?? subLabel}** — ${postRecords.length} posts, ${commentRecords.length} comments`,
+      `Sentiment: ${avgScore.toFixed(2)} (${sentimentLabel})`,
+    ];
+
+    if (firstResult.topMentions.length > 0) {
+      lines.push(`Tickers: ${firstResult.topMentions.map((t) => `$${t}`).join(", ")}`);
+    }
+
+    lines.push("");
+    lines.push("Top posts:");
+    for (const post of postRecords.slice(0, 10)) {
+      const scoreIndicator = post.sentiment.score > 0 ? "🟢" : post.sentiment.score < 0 ? "🔴" : "⚪";
+      lines.push(`  ${scoreIndicator} ⬆${post.engagement.score} 💬${post.engagement.replies ?? 0} — ${(post.title ?? post.text).slice(0, 100)}`);
+    }
+
+    if (pipelineResult.trend && pipelineResult.trend.length > 0) {
+      const t = pipelineResult.trend[0];
+      lines.push("");
+      lines.push(`Trend: ${t.sparkline} ${t.direction} (${t.delta >= 0 ? "+" : ""}${t.delta.toFixed(2)}, ${t.count} records)`);
+    }
+
+    if (warnings.length > 0) {
+      lines.push("");
+      lines.push(`⚠ ${warnings.join("; ")}`);
+    }
+
+    return { content: [{ type: "text", text: lines.join("\n") }], details: firstResult };
+  },
+};

package/src/tools/sentiment/sentiment-summary.ts

@@ -0,0 +1,256 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getSubredditPosts, getPostComments } from "../../providers/reddit.js";
+import { getTwitterSentiment } from "../../providers/twitter.js";
+import { searchWeb } from "../../providers/web-search.js";
+import { getCompanyNews, finnhubDateRange } from "../../providers/finnhub.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import { getConfig } from "../../config.js";
+import { TwitterAdapter } from "../../sentiment/adapters/twitter.js";
+import { RedditAdapter } from "../../sentiment/adapters/reddit.js";
+import { WebAdapter } from "../../sentiment/adapters/web.js";
+import { FinnhubAdapter, extractTickersFromQuery } from "../../sentiment/adapters/finnhub.js";
+import { getSentimentPipeline } from "../../sentiment/index.js";
+import type { SentinelRecord } from "../../sentiment/types.js";
+import { hasCredential } from "../../onboarding/providers.js";
+import { buildSoftDegradedTag } from "../../onboarding/tool-tags.js";
+
+const params = Type.Object({
+  query: Type.String({ description: "Ticker or topic for cross-source sentiment summary" }),
+  hours: Type.Optional(
+    Type.Number({ description: "Lookback window in hours for live fetching. Default: 24" }),
+  ),
+});
+
+export const sentimentSummaryTool: AgentTool<typeof params> = {
+  name: "get_sentiment_summary",
+  label: "Sentiment Summary",
+  description:
+    "Cross-source sentiment summary combining Twitter, Reddit, and web/news. Returns per-source scores, aggregate sentiment, and divergence detection.",
+  parameters: params,
+  async execute(toolCallId, args) {
+    const hours = args.hours ?? 24;
+    const config = getConfig();
+    const warnings: string[] = [];
+    const allRecords: SentinelRecord[] = [];
+
+    const twitterAdapter = new TwitterAdapter();
+    const redditAdapter = new RedditAdapter();
+    const webAdapter = new WebAdapter();
+    const finnhubAdapter = new FinnhubAdapter();
+
+    // Determine if Finnhub should be included (key configured + ticker in
+    // query). `candidateTickers` is extracted unconditionally so we can tell
+    // a "no finnhub-mappable ticker in the query" case apart from a "query
+    // has tickers but user has no Finnhub key" case — the latter warrants a
+    // soft-degraded tag so the LLM surfaces it in the Data gaps section.
+    const candidateTickers = extractTickersFromQuery(args.query);
+    const finnhubTickers = config.finnhubApiKey ? candidateTickers : [];
+    const includeFinnhub = finnhubTickers.length > 0 && Boolean(config.finnhubApiKey);
+    const finnhubSoftDegraded =
+      candidateTickers.length > 0 && !hasCredential("finnhub");
+
+    // Finnhub fetch (built separately to avoid mixing promise types in allSettled)
+    const finnhubFetch: Promise<import("../../providers/finnhub.js").FinnhubArticle[]> = includeFinnhub
+      ? (async () => {
+          const { from, to } = finnhubDateRange("day");
+          const arrays = await Promise.all(
+            finnhubTickers.map((sym) => getCompanyNews(sym, from, to, config.finnhubApiKey!)),
+          );
+          return arrays.flat();
+        })()
+      : Promise.resolve([]);
+
+    // Fetch all sources in parallel
+    const [twitterResult, redditResults, webResult, finnhubResult] = await Promise.allSettled([
+      // Twitter
+      wrapProvider("twitter", () => getTwitterSentiment(args.query, 50, hours)),
+      // Reddit — cross-subreddit
+      fetchRedditCrossSubreddit(args.query, config.sentiment?.defaultSubreddits ?? ["wallstreetbets", "stocks", "investing", "options"]),
+      // Web
+      searchWeb(args.query, { freshness: "day", limit: 10, category: "news" }),
+      // Finnhub — only when includeFinnhub; otherwise resolves to []
+      finnhubFetch,
+    ]);
+
+    // Process Twitter
+    if (twitterResult.status === "fulfilled" && twitterResult.value.status === "ok") {
+      const records = twitterAdapter.mapToRecords(twitterResult.value.data, args.query);
+      allRecords.push(...records);
+    } else {
+      const reason = twitterResult.status === "rejected"
+        ? twitterResult.reason?.message ?? "unknown error"
+        : (twitterResult.value as any).reason ?? "unavailable";
+      warnings.push(`Twitter: ${reason}`);
+    }
+
+    // Process Reddit
+    if (redditResults.status === "fulfilled") {
+      const { records: redditRecords, warnings: redditWarnings } = redditResults.value;
+      allRecords.push(...redditRecords);
+      warnings.push(...redditWarnings);
+    } else {
+      warnings.push(`Reddit: ${redditResults.reason?.message ?? "unknown error"}`);
+    }
+
+    // Process Web
+    if (webResult.status === "fulfilled" && webResult.value.status === "ok") {
+      const records = webAdapter.mapToRecords(webResult.value.data, args.query);
+      allRecords.push(...records);
+    } else {
+      const reason = webResult.status === "rejected"
+        ? webResult.reason?.message ?? "unknown error"
+        : (webResult.value as any).reason ?? "unavailable";
+      warnings.push(`Web: ${reason}`);
+    }
+
+    // Process Finnhub (only when included — otherwise resolves to empty array anyway)
+    if (includeFinnhub) {
+      if (finnhubResult.status === "fulfilled") {
+        const articles = finnhubResult.value;
+        if (articles.length > 0) {
+          const records = finnhubAdapter.mapToRecords(articles, args.query);
+          allRecords.push(...records);
+        }
+      } else {
+        warnings.push(`Finnhub: ${finnhubResult.reason?.message ?? "unknown error"}`);
+      }
+    }
+
+    const softDegradedPrefix = finnhubSoftDegraded
+      ? `${buildSoftDegradedTag({
+          provider: "finnhub",
+          fallback: "other-sentiment-sources",
+          remediation: "run /connect news to enable Finnhub company news",
+        })}\n\n`
+      : "";
+
+    if (allRecords.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${softDegradedPrefix}⚠ Sentiment summary unavailable for "${args.query}" — no sources returned data.\n${warnings.join("\n")}`,
+          },
+        ],
+        details: null as any,
+      };
+    }
+
+    // Score and index through pipeline
+    const pipeline = getSentimentPipeline();
+    const result = await pipeline.processRecords(allRecords, args.query);
+
+    // Group by source (exclude comments from per-source averages)
+    const bySource: Record<string, { total: number; count: number }> = {};
+    for (const rec of result.fresh) {
+      if (rec.metadata.isComment) continue;
+      if (!bySource[rec.source]) bySource[rec.source] = { total: 0, count: 0 };
+      bySource[rec.source].total += rec.sentiment.score;
+      bySource[rec.source].count++;
+    }
+
+    const lines: string[] = [];
+    lines.push(`**Sentiment summary for "${args.query}"** (last ${hours}h):`);
+    lines.push("");
+    lines.push("| Source | Score | Count | Signal |");
+    lines.push("|--------|-------|-------|--------|");
+
+    let totalScore = 0;
+    let totalCount = 0;
+    for (const [source, stats] of Object.entries(bySource)) {
+      const avg = stats.count > 0 ? stats.total / stats.count : 0;
+      const label = sentimentLabel(avg);
+      const sourceName = source === "web" ? "Web/News" : source.charAt(0).toUpperCase() + source.slice(1);
+      lines.push(`| ${sourceName} | ${avg >= 0 ? "+" : ""}${avg.toFixed(2)} | ${stats.count} | ${label} |`);
+      totalScore += stats.total;
+      totalCount += stats.count;
+    }
+
+    const aggregate = totalCount > 0 ? totalScore / totalCount : 0;
+    lines.push("");
+    lines.push(`**Aggregate:** ${aggregate >= 0 ? "+" : ""}${aggregate.toFixed(2)} (${sentimentLabel(aggregate)})`);
+
+    // Divergence
+    if (result.divergence && result.divergence.detected) {
+      lines.push("");
+      lines.push(result.divergence.message);
+    } else if (result.divergence && !result.divergence.detected) {
+      lines.push("");
+      lines.push(result.divergence.message);
+    }
+
+    // Trend
+    if (result.trend && result.trend.length > 0) {
+      const t = result.trend[0];
+      lines.push("");
+      lines.push(`Trend: ${t.sparkline} ${t.direction} (${t.count} records)`);
+    }
+
+    if (warnings.length > 0) {
+      lines.push("");
+      lines.push(warnings.map((w) => `⚠ ${w}`).join("\n"));
+    }
+
+    const output = softDegradedPrefix + lines.join("\n");
+    return { content: [{ type: "text", text: output }], details: result };
+  },
+};
+
+async function fetchRedditCrossSubreddit(
+  query: string,
+  subreddits: string[],
+): Promise<{ records: SentinelRecord[]; warnings: string[] }> {
+  const adapter = new RedditAdapter();
+  const records: SentinelRecord[] = [];
+  const warnings: string[] = [];
+  const config = getConfig();
+  const commentsPerPost = config.sentiment?.commentsPerPost ?? 5;
+
+  for (const sub of subreddits) {
+    const result = await wrapProvider("reddit", () => getSubredditPosts(sub, 25));
+    if (result.status === "unavailable") {
+      warnings.push(`Reddit r/${sub}: ${result.reason}`);
+      continue;
+    }
+    const postRecords = adapter.mapPostsToRecords(result.data, query);
+
+    // Topic filter
+    const queryLower = query.toLowerCase();
+    const filtered = postRecords.filter((r) =>
+      r.text.toLowerCase().includes(queryLower) ||
+      (r.title?.toLowerCase().includes(queryLower) ?? false),
+    );
+    records.push(...filtered);
+
+    // Fetch comments for top posts
+    const topPosts = [...filtered]
+      .sort((a, b) => b.engagement.score - a.engagement.score)
+      .slice(0, 3); // fewer per sub since we're searching multiple
+    for (const post of topPosts) {
+      if ((post.engagement.replies ?? 0) === 0) continue;
+      try {
+        const comments = await getPostComments(sub, post.sourceId, commentsPerPost);
+        records.push(...adapter.mapCommentsToRecords(comments, post.sourceId, sub, query));
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  // Deduplicate
+  const seen = new Set<string>();
+  const deduped = records.filter((r) => {
+    if (seen.has(r.sourceId)) return false;
+    seen.add(r.sourceId);
+    return true;
+  });
+
+  return { records: deduped, warnings };
+}
+
+function sentimentLabel(score: number): string {
+  if (score > 0.3) return "Bullish";
+  if (score < -0.3) return "Bearish";
+  if (score > 0) return "Leaning Bullish";
+  if (score < 0) return "Leaning Bearish";
+  return "Neutral";
+}

package/src/tools/sentiment/sentiment-trend.ts

@@ -0,0 +1,58 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { SentimentStore } from "../../sentiment/store.js";
+import { getSentimentStore } from "../../sentiment/index.js";
+import { computeTrend } from "../../sentiment/trends.js";
+
+const params = Type.Object({
+  query: Type.String({ description: "Ticker or topic to look up sentiment history" }),
+  days: Type.Optional(
+    Type.Number({ description: "Number of days of history. Default: 7, max: 30" }),
+  ),
+  source: Type.Optional(
+    Type.Union([Type.Literal("twitter"), Type.Literal("reddit"), Type.Literal("web"), Type.Literal("finnhub")], {
+      description: "Filter to a single source. Default: all sources.",
+    }),
+  ),
+});
+
+interface TrendToolResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: any;
+}
+
+export const sentimentTrendTool: AgentTool<typeof params> & {
+  executeWithStore: (toolCallId: string, args: { query: string; days?: number; source?: string }, store: SentimentStore) => Promise<TrendToolResult>;
+} = {
+  name: "get_sentiment_trend",
+  label: "Sentiment Trend",
+  description:
+    "Query historical sentiment data from the local store. No live API calls — returns trends from previously fetched data. Run a sentiment query first to populate the store.",
+  parameters: params,
+  async execute(toolCallId, args) {
+    const store = getSentimentStore();
+    return sentimentTrendTool.executeWithStore(toolCallId, args, store);
+  },
+  async executeWithStore(_toolCallId, args, store) {
+    const days = Math.min(args.days ?? 7, 30);
+    const series = store.getTimeSeries(args.query, { days, bucketHours: 24 });
+
+    if (series.length === 0) {
+      return {
+        content: [{ type: "text", text: `No historical sentiment data for "${args.query}". Run a sentiment query first to populate the store.` }],
+        details: null,
+      };
+    }
+
+    const trend = computeTrend(series, (args.source as any) ?? "aggregate");
+
+    const lines = [
+      `**Sentiment trend for "${args.query}"** (${days}d):`,
+      "",
+      `${trend.sparkline}  ${trend.direction} (${trend.delta >= 0 ? "+" : ""}${trend.delta.toFixed(2)})`,
+      `Avg: ${trend.avgScore.toFixed(2)} | Records: ${trend.count}`,
+    ];
+
+    return { content: [{ type: "text", text: lines.join("\n") }], details: { trend, series } };
+  },
+};

package/src/tools/sentiment/twitter-sentiment.ts

@@ -0,0 +1,96 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getTwitterSentiment } from "../../providers/twitter.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import type { TwitterSentimentResult } from "../../types/sentiment.js";
+import { TwitterAdapter } from "../../sentiment/adapters/twitter.js";
+import { getSentimentPipeline } from "../../sentiment/index.js";
+
+const params = Type.Object({
+  query: Type.String({
+    description: "Stock ticker (e.g. AAPL) or search term (e.g. 'AAPL earnings call')",
+  }),
+  limit: Type.Optional(
+    Type.Number({ description: "Max tweets to fetch. Default: 50, max: 200" }),
+  ),
+  hours: Type.Optional(
+    Type.Number({ description: "Lookback window in hours. Default: 24" }),
+  ),
+});
+
+export const twitterSentimentTool: AgentTool<typeof params, TwitterSentimentResult> = {
+  name: "get_twitter_sentiment",
+  label: "Twitter Sentiment",
+  description:
+    "Fetch recent tweets for a stock ticker or search query and compute engagement-weighted sentiment. Returns tweet data, sentiment score, and co-mentioned tickers. Requires a Twitter session via trigger_twitter_login.",
+  parameters: params,
+  async execute(toolCallId, args) {
+    const limit = Math.min(args.limit ?? 50, 200);
+    const hours = args.hours ?? 24;
+
+    const providerResult = await wrapProvider("twitter", () =>
+      getTwitterSentiment(args.query, limit, hours),
+    );
+
+    if (providerResult.status === "unavailable") {
+      const isLoginIssue =
+        providerResult.reason.includes("No Twitter session") ||
+        providerResult.reason.includes("session expired");
+      const text = isLoginIssue
+        ? `⚠ Twitter sentiment unavailable: ${providerResult.reason}\n[LOGIN_NEEDED] Use ask_user to confirm, then call trigger_twitter_login. After success, retry this tool.`
+        : `⚠ Twitter sentiment unavailable (${providerResult.reason}).`;
+      return {
+        content: [{ type: "text", text }],
+        details: null as any,
+      };
+    }
+
+    const result = providerResult.data;
+
+    const sentimentLabel =
+      result.sentimentScore > 0.3 ? "Bullish" :
+      result.sentimentScore < -0.3 ? "Bearish" :
+      result.sentimentScore > 0 ? "Leaning Bullish" :
+      result.sentimentScore < 0 ? "Leaning Bearish" : "Neutral";
+
+    const lines = [
+      `**Twitter: ${result.query}** — ${result.tweetCount} tweets (last ${hours}h, ${result.fetchedAt})`,
+      `Sentiment: ${result.sentimentScore.toFixed(2)} (${sentimentLabel}) | Bullish: ${result.bullishCount} | Bearish: ${result.bearishCount}`,
+    ];
+
+    if (result.topMentions.length > 0) {
+      lines.push(`Co-mentions: ${result.topMentions.map((t) => `$${t}`).join(", ")}`);
+    }
+
+    lines.push("");
+    lines.push("| Author | Tweet | ❤️ | 🔁 | 💬 |");
+    lines.push("|--------|-------|----|----|----|");
+    const top = result.tweets.slice(0, 15);
+    for (const tweet of top) {
+      const text = tweet.text.replace(/\|/g, "\\|").replace(/\n/g, " ").slice(0, 100);
+      lines.push(`| @${tweet.author} | ${text} | ${tweet.likes} | ${tweet.retweets} | ${tweet.replies} |`);
+    }
+
+    if (providerResult.stale) {
+      lines.push("");
+      lines.push(`⚠ Stale data (cached at ${providerResult.timestamp})`);
+    }
+
+    // Index in sentiment store and append trend context
+    try {
+      const adapter = new TwitterAdapter();
+      const records = adapter.mapToRecords(result, args.query);
+      const pipeline = getSentimentPipeline();
+      const pipelineResult = await pipeline.processRecords(records, args.query);
+      if (pipelineResult.trend && pipelineResult.trend.length > 0) {
+        const t = pipelineResult.trend[0];
+        lines.push("");
+        lines.push(`Trend: ${t.sparkline} ${t.direction} (${t.delta >= 0 ? "+" : ""}${t.delta.toFixed(2)}, ${t.count} records)`);
+      }
+    } catch {
+      // Sentiment indexing is best-effort — don't fail the tool
+    }
+
+    return { content: [{ type: "text", text: lines.join("\n") }], details: result };
+  },
+};