Initial commit

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/FinnAI.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.13 (FinnAI)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.13 (PyCharmMiscProject)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 (FinnAI)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/FinnAI.iml" filepath="$PROJECT_DIR$/.idea/FinnAI.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.streamlit/secrets.toml

@@ -0,0 +1,2 @@
+# .streamlit/secrets.toml
+GOOGLE_API_KEY = "AIzaSyBxrJAxe69t02jMZKtOGXY3gCIgVm8RAMY"

agent/agent.py

@@ -0,0 +1,122 @@
+import streamlit as st
+import sys
+from langchain_openai import ChatOpenAI
+from langchain.agents import create_openai_tools_agent, AgentExecutor
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.tools import tool
+from langchain_experimental.tools.python.tool import PythonREPLTool
+from . import utils
+
+
+python_repl = PythonREPLTool(python_path=sys.executable)
+
+@tool
+def code_analysis(code: str) -> str:
+    """Takes python code and gives back the output."""
+    return python_repl.run(code)
+
+@tool
+def get_revenue_variance(start_month: str, end_month: str) -> float:
+    """Calculate revenue variance (revenue vs budget) in USD over a date range."""
+    return utils.revenue_variance(start_month, end_month)
+
+@tool
+def get_gross_margin_pct(start_month: str, end_month: str) -> float:
+    """Calculate month on month gross margin percentage over a date range."""
+    return utils.gross_margin_pct(start_month, end_month)
+
+@tool
+def get_opex_breakdown(start_month: str, end_month: str) -> dict:
+    """Break down operating expenses by category in USD over a date range."""
+    return utils.opex_breakdown(start_month, end_month)
+
+@tool
+def get_ebitda_proxy(start_month: str, end_month: str) -> float:
+    """Calculate proxy EBITDA over a date range."""
+    return utils.ebitda_proxy(start_month, end_month)
+
+@tool
+def get_cash_runway(as_of_month: str = None, last_n_months: int = 3) -> float:
+    """Calculate cash runway in months based on historical or current burn rate."""
+    return utils.cash_runway(as_of_month, last_n_months)
+
+@tool
+def plot_chart(chart_type: str, x: list, y: list, title: str, x_label: str, y_label: str, output_path: str = "chart.png", legends: list[str] | None = None) -> str:
+    """Generate and save a graph/chart with the specified data and formatting."""
+    return utils.plot_chart(chart_type, x, y, title, x_label, y_label, output_path, legends)
+
+
+@st.cache_resource
+def initialize_agent():
+    """
+    Initializes and returns the LangChain agent executor.
+    This function is now self-contained and handles all agent logic.
+    """
+
+    try:
+        gemini_client = ChatOpenAI(
+            api_key=st.secrets["GOOGLE_API_KEY"],
+            base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+            model="gemini-2.0-flash",
+            temperature=0.2
+        )
+    except (KeyError, FileNotFoundError):
+        st.error("GOOGLE_API_KEY not found. Please add it to your .streamlit/secrets.toml file.")
+        st.stop()
+
+    # --- Tool Definitions ---
+
+    # --- System Prompt ---
+    ma_prompt = ChatPromptTemplate.from_messages([
+        ("system", """
+    You are the Smart Financial Analytics Agent.
+
+    You have access to data from an Excel file with these sheets:
+    - actuals: (month, entity, account_category, amount, currency)
+    - budget: (month, entity, account_category, amount, currency)
+    - cash: (month, entity, cash_usd)
+    - fx: (month, currency, rate_to_usd)
+
+    Key points:
+    - Always verify currencies. Default to USD; if EUR, convert using the fx sheet.
+    - Months may appear as “YYYY-MM”, “June 2025”, “Jun’25”, etc. Treat them as equivalent.
+    - account_category has values: Revenuem, COGS, Opex:Marketing, Opex:Sales, Opex:R&D, Opex:Admin
+
+    Metric definitions:
+    -Revenue (USD): actual vs budget.
+    -Gross Margin %: (Revenue – COGS) / Revenue.
+    -Opex total (USD): grouped by Opex:* categories.
+    -EBITDA (proxy): Revenue – COGS – Opex.
+    -Cash runway: cash ÷ avg monthly net burn (last 3 months).
+
+    Dates:
+    - Range 2023-01 to 2025-12
+    - Normalize month formats into the same period.
+    - If the user says "current year" or "this year", map it to the latest year in the dataset (2025).
+    - If the user specifies a month without a year, default to the latest year available (2025).
+    - If the request refers to a year outside the dataset range (2023–2025) or no matching data exists, ask the user for clarification.
+
+    ONLY and ONLY,
+    If user asked something which cannot be fulfilled by a tool (where the params not allow, or tool is not capabale etc.). Make your own code and pass it to the code_analysis tool use the 'data.xlsx' file.
+    Do retry if code throws error. 
+
+    Instructions:
+    1. If the user’s request matches a tool, call it. You can call multiple tools multiple times if needed.
+    2. Only call the 'code_analysis' tool as a last resort if no other tool is suitable.
+    3. After a tool call:
+       - Lead with the direct answer/figures.
+       - Give a short interpretation (context, implications).
+       - If a chart is generated, confirm that the chart is now displayed.
+    4. Keep answers concise, actionable, and financially relevant, remember you are answer directly to the CFO of the company.
+    """),
+        MessagesPlaceholder("chat_history", optional=True),
+        ("human", "{input}"),
+        MessagesPlaceholder("agent_scratchpad")
+    ])
+
+    # --- Agent and Executor Creation ---
+    tools = [code_analysis, get_cash_runway, get_ebitda_proxy, get_opex_breakdown, get_revenue_variance, get_gross_margin_pct, plot_chart]
+    main_agent = create_openai_tools_agent(llm=gemini_client, tools=tools, prompt=ma_prompt)
+    agent_executor = AgentExecutor(agent=main_agent, tools=tools, verbose=True, return_intermediate_steps=True)
+
+    return agent_executor

agent/utils.py

@@ -0,0 +1,199 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Load and prepare data
+dfs = pd.read_excel("data.xlsx", sheet_name=None)
+actuals = dfs["actuals"].copy()
+budget = dfs["budget"].copy()
+cash = dfs["cash"].copy()
+fx = dfs["fx"].copy()
+
+# Normalize month columns
+for df in (actuals, budget, cash, fx):
+    df["month"] = pd.to_datetime(df["month"]).dt.to_period("M")
+
+# Helper: convert any DataFrame with `amount` & `currency` to USD
+def convert_to_usd(df: pd.DataFrame, fx: pd.DataFrame) -> pd.DataFrame:
+    merged = df.merge(
+        fx,
+        on=["month", "currency"],
+        how="left",
+        suffixes=("", "_fx"),
+    )
+    merged["rate_to_usd"] = merged["rate_to_usd"].fillna(1.0)
+    merged["amount_usd"] = merged["amount"] * merged["rate_to_usd"]
+    return merged
+
+# 1. Revenue variance
+def revenue_variance(start_month: str, end_month: str) -> float:
+    a = convert_to_usd(actuals, fx)
+    b = convert_to_usd(budget, fx)
+    mask = lambda df: (df["month"] >= pd.Period(start_month)) & (df["month"] <= pd.Period(end_month))
+    actual_rev = a[mask(a) & (a["account_category"] == "Revenue")]["amount_usd"].sum()
+    budget_rev = b[mask(b) & (b["account_category"] == "Revenue")]["amount_usd"].sum()
+    return actual_rev - budget_rev, actual_rev, budget_rev
+
+# 2. Gross Margin %
+def gross_margin_pct(start_month: str, end_month: str) -> float:
+    a = convert_to_usd(actuals, fx)
+    mask = (a["month"] >= pd.Period(start_month)) & (a["month"] <= pd.Period(end_month))
+
+    result = {}
+    for m in sorted(a[mask]["month"].unique()):
+        sub = a[a["month"] == m]
+        rev = sub[sub["account_category"] == "Revenue"]["amount_usd"].sum()
+        cogs = sub[sub["account_category"] == "COGS"]["amount_usd"].sum()
+        result[str(m)] = round((rev - cogs) / rev * 100, 2) if rev != 0 else 0.0
+
+    return result
+
+# 3. Opex breakdown
+def opex_breakdown(start_month: str, end_month: str) -> dict:
+    a = convert_to_usd(actuals, fx)
+    mask = (a["month"] >= pd.Period(start_month)) & (a["month"] <= pd.Period(end_month))
+    opex = a[mask & a["account_category"].str.startswith("Opex")]
+    return opex.groupby("account_category")["amount_usd"].sum().to_dict()
+
+# 4. EBITDA proxy
+def ebitda_proxy(start_month: str, end_month: str) -> float:
+    a = convert_to_usd(actuals, fx)
+    mask = (a["month"] >= pd.Period(start_month)) & (a["month"] <= pd.Period(end_month))
+    rev = a[mask & (a["account_category"] == "Revenue")]["amount_usd"].sum()
+    cogs = a[mask & (a["account_category"] == "COGS")]["amount_usd"].sum()
+    opex = a[mask & a["account_category"].str.startswith("Opex")]["amount_usd"].sum()
+    return rev - cogs - opex
+
+# 5. Cash runway
+def cash_runway(as_of_month: str = None, last_n_months: int = 3) -> float:
+    # If no as_of_month specified, use most recent
+    if as_of_month is None:
+        most_recent = cash["month"].max()
+    else:
+        most_recent = pd.Period(as_of_month)
+
+    # Get cash balance as of the specified/most recent month
+    cash_usd = cash[cash["month"] == most_recent]["cash_usd"].sum()
+
+    # Calculate net burn for each of the last N months before as_of_month
+    a = convert_to_usd(actuals, fx)
+
+    # Get months ending before as_of_month
+    available_months = sorted([m for m in a["month"].unique() if m < most_recent])
+    months = available_months[-last_n_months:] if len(available_months) >= last_n_months else available_months
+
+    burns = []
+    for m in months:
+        dfm = a[a["month"] == m]
+        rev = dfm[dfm["account_category"] == "Revenue"]["amount_usd"].sum()
+        cogs = dfm[dfm["account_category"] == "COGS"]["amount_usd"].sum()
+        opex = dfm[dfm["account_category"].str.startswith("Opex")]["amount_usd"].sum()
+        burns.append(cogs + opex - rev)
+
+    avg_burn = sum(burns) / len(burns) if burns else 0
+    return cash_usd / avg_burn if avg_burn > 0 else float('inf'), avg_burn
+
+def plot_chart(
+    chart_type: str,
+    x,
+    y,
+    title: str,
+    x_label: str,
+    y_label: str,
+    output_path: str,
+    legends: list[str] | None = None,   # ← NEW
+) -> str:
+    """
+            Plot helper that supports single-series and multi-series
+            bar, line, scatter and pie charts.
+
+            Parameters
+            ----------
+            chart_type : {"bar", "line", "scatter", "pie"}
+            x, y       : list-like objects.  For multi-series data,
+                         use y = [[series1], [series2], …] and
+                         x  = [[categories]].
+            legends    : Optional list of legend labels, one per series.
+            """
+    try:
+
+        plt.figure(figsize=(7, 4))
+
+        # ── MULTI-SERIES ────────────────────────────────────────────────
+        if isinstance(y[0], list) and len(y) > 1:
+            categories = x[0]  # shared x-axis
+            n_groups = len(categories)
+            n_series = len(y)
+
+            if chart_type == "bar":
+                bar_width = 0.8 / n_series
+                x_pos = np.arange(n_groups)
+                colors = ['#1f77b4', '#ff7f0e', '#2ca02c',
+                          '#d62728', '#9467bd']
+
+                for i, series in enumerate(y):
+                    offset = (i - n_series / 2 + 0.5) * bar_width
+                    plt.bar(
+                        x_pos + offset,
+                        series,
+                        bar_width,
+                        color=colors[i % len(colors)],
+                        label=(legends[i] if legends and i < len(legends)
+                               else f"Series {i + 1}")
+                    )
+
+                plt.xticks(x_pos, categories, rotation=45)
+                plt.legend()
+
+            elif chart_type == "line":
+                for i, series in enumerate(y):
+                    plt.plot(
+                        categories,
+                        series,
+                        marker="o",
+                        label=(legends[i] if legends and i < len(legends)
+                               else f"Series {i + 1}")
+                    )
+                plt.legend()
+                plt.xticks(rotation=45)
+
+        # ── SINGLE-SERIES ───────────────────────────────────────────────
+        else:
+            # flatten if wrapped
+            if isinstance(y[0], list): y = y[0]
+            if isinstance(x[0], list): x = x[0]
+
+            if chart_type == "line":
+                plt.plot(x, y, marker="o", linewidth=2, markersize=6,
+                         label=legends[0] if legends else None)
+            elif chart_type == "bar":
+                plt.bar(x, y, color="skyblue", edgecolor="navy", alpha=0.7,
+                        label=legends[0] if legends else None)
+                plt.xticks(rotation=45)
+                plt.ylim(bottom=0)
+            elif chart_type == "scatter":
+                plt.scatter(x, y, s=60, alpha=0.7,
+                            label=legends[0] if legends else None)
+            elif chart_type == "pie":
+                plt.pie(y, labels=x, autopct="%1.1f%%", startangle=90)
+                plt.axis("equal")
+
+            if legends and chart_type != "pie":
+                plt.legend()
+
+        # ── COMMON FORMATTING ──────────────────────────────────────────
+        plt.title(title, fontsize=14, fontweight="bold")
+
+        if chart_type != "pie":
+            plt.xlabel(x_label, fontsize=12)
+            plt.ylabel(y_label, fontsize=12)
+            plt.grid(True, alpha=0.3)
+
+        plt.tight_layout()
+        plt.savefig(output_path, dpi=100, bbox_inches="tight")
+        plt.close()
+        return output_path
+
+    except Exception as e:
+        return f'There is some problem with the data you send, I am using matplotlib to plot. Can you send a full code to other tool which could run on PythonREPLTool (should save the graph and return the filename). Here is the error: {e}'
+        # return f'There is some problem with the data you send, I am using matplotlib to plot. Can you recheck the data and send it again. May be just include the most important field to plot. Here is the error: {e}'

app.py

@@ -0,0 +1,85 @@
+# app.py
+import re
+
+import streamlit as st
+from langchain_core.messages import AIMessage, HumanMessage
+
+# Import the agent initializer from its new location
+from agent.agent import initialize_agent
+
+def extract_image_paths(text: str) -> list[str]:
+    """
+    Finds all image filenames (png/jpeg) in a block of text,
+    whether in quotes or bare.
+    """
+    return re.findall(r"['\"]?([A-Za-z0-9_\-]+\.(?:png|jpg|jpeg))['\"]?", text)
+
+
+st.set_page_config(page_title="🤖 Smart Financial Analytics Agent", layout="wide")
+st.title("🤖 CFO Copilot")
+
+# Initialize the agent
+agent_executor = initialize_agent()
+
+# Initialize chat history in session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Display past messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+
+        st.text(message["content"])
+        if "image_path" in message and message["image_path"]:
+            st.image(message["image_path"])
+
+# Get user input
+if prompt := st.chat_input("Ask a question about your financial data..."):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    # Generate and display assistant response
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            chat_history = [
+                HumanMessage(content=msg["content"]) if msg["role"] == "user" else AIMessage(content=msg["content"])
+                for msg in st.session_state.messages[:-1]
+            ]
+
+            response = agent_executor.invoke({
+                "input": prompt,
+                "chat_history": chat_history
+            })
+
+            output_text = response["output"]
+            st.text(output_text)
+
+            # Collect any image paths from intermediate steps & output
+            image_paths = []
+
+            # 1. From intermediate_steps (even if action.tool != 'plot_chart')
+            for step in response.get("intermediate_steps", []):
+                _, observation = step
+                # observation might be a filename or a descriptive text
+                if isinstance(observation, str):
+                    image_paths += extract_image_paths(observation)
+
+            # 2. From the assistant’s final output text
+            image_paths += extract_image_paths(output_text)
+
+            # 3. De-duplicate and display
+            for path in dict.fromkeys(image_paths):  # preserves order, removes dups
+                try:
+                    st.image(path)
+                    # also record for session state
+                    image_path = path
+                except Exception as e:
+                    st.error(f"Failed to load image {path}: {e}")
+
+            # Save session state
+            st.session_state.messages.append({
+                "role": "assistant",
+                "content": output_text,
+                "image_path": image_path if image_paths else None
+            })

requirements.txt

@@ -0,0 +1,14 @@
+langchain==0.3.27
+langchain-community==0.3.30
+langchain-core==0.3.76
+langchain-experimental==0.3.4
+langchain-google-genai==2.1.12
+langchain-openai==0.3.33
+langchain-text-splitters==0.3.11
+matplotlib==3.10.6
+matplotlib-inline==0.1.7
+numpy==2.3.3
+pandas==2.3.2
+pytest==8.4.2
+pytest-mock==3.15.1
+streamlit==1.50.0

tests/test_1.py

@@ -0,0 +1,106 @@
+# test_module_level_tools.py
+import pytest
+from unittest.mock import patch, Mock
+from agent import agent
+from agent.agent import (
+    code_analysis,
+    get_revenue_variance,
+    get_gross_margin_pct,
+    get_opex_breakdown,
+    get_ebitda_proxy,
+    get_cash_runway,
+    plot_chart
+)
+
+
+class TestModuleLevelTools:
+    """Test the module-level tool definitions"""
+
+    def test_tools_have_correct_decorators(self):
+        """Test that all tools are properly decorated"""
+        tools = [
+            code_analysis,
+            get_revenue_variance,
+            get_gross_margin_pct,
+            get_opex_breakdown,
+            get_ebitda_proxy,
+            get_cash_runway,
+            plot_chart
+        ]
+
+        for tool in tools:
+            # Check that tool has required attributes from @tool decorator
+            assert hasattr(tool, 'name'), f"Tool {tool} missing 'name' attribute"
+            assert hasattr(tool, 'description'), f"Tool {tool} missing 'description' attribute"
+            assert hasattr(tool, 'args_schema'), f"Tool {tool} missing 'args_schema' attribute"
+
+    def test_tool_names_are_correct(self):
+        """Test that tool names match function names"""
+        expected_names = {
+            'code_analysis': code_analysis.name,
+            'get_revenue_variance': get_revenue_variance.name,
+            'get_gross_margin_pct': get_gross_margin_pct.name,
+            'get_opex_breakdown': get_opex_breakdown.name,
+            'get_ebitda_proxy': get_ebitda_proxy.name,
+            'get_cash_runway': get_cash_runway.name,
+            'plot_chart': plot_chart.name,
+        }
+
+        for expected_name, actual_name in expected_names.items():
+            assert expected_name == actual_name
+
+    def test_tool_descriptions_exist(self):
+        """Test that all tools have non-empty descriptions"""
+        tools = [code_analysis, get_revenue_variance, get_gross_margin_pct,
+                 get_opex_breakdown, get_ebitda_proxy, get_cash_runway, plot_chart]
+
+        for tool in tools:
+            assert tool.description is not None
+            assert len(tool.description.strip()) > 0
+
+    @patch('agent.utils.revenue_variance')
+    def test_get_revenue_variance_tool_execution(self, mock_utils_func):
+        """Test revenue variance tool execution"""
+        mock_utils_func.return_value = 5000.0
+
+        result = get_revenue_variance.invoke({
+            'start_month': '2025-01',
+            'end_month': '2025-01'
+        })
+
+        assert result == 5000.0
+        mock_utils_func.assert_called_once_with('2025-01', '2025-01')
+
+    @patch('agent.utils.cash_runway')
+    def test_get_cash_runway_tool_execution(self, mock_utils_func):
+        """Test cash runway tool with optional parameters"""
+        mock_utils_func.return_value = 12.5
+
+        # Test with default parameters
+        result = get_cash_runway.invoke({})
+        assert result == 12.5
+        mock_utils_func.assert_called_once_with(None, 3)
+
+        # Test with custom parameters
+        mock_utils_func.reset_mock()
+        result = get_cash_runway.invoke({
+            'as_of_month': '2025-01',
+            'last_n_months': 6
+        })
+        assert result == 12.5
+        mock_utils_func.assert_called_once_with('2025-01', 6)
+
+    def test_python_repl_tool_instance(self):
+        """Test that python_repl is properly initialized"""
+        assert agent.python_repl is not None
+        assert hasattr(agent.python_repl, 'run')
+
+    @patch('agent.agent.python_repl')
+    def test_code_analysis_tool_execution(self, mock_python_repl):
+        """Test code analysis tool execution"""
+        mock_python_repl.run.return_value = "Output: 42"
+
+        result = code_analysis.invoke({'code': 'print(21 * 2)'})
+
+        assert result == "Output: 42"
+        mock_python_repl.run.assert_called_once_with('print(21 * 2)')

tests/test_2.py

@@ -0,0 +1,27 @@
+# tests/test_agent_tool_selection_updated.py
+import pytest
+from unittest.mock import patch, Mock
+from agent.agent import initialize_agent
+from langchain.agents.agent import AgentExecutor
+
+class TestAgentToolSelectionUpdated:
+
+    @pytest.fixture(autouse=True)
+    def setup_agent(self):
+        with patch("streamlit.secrets", {"GOOGLE_API_KEY": "AIzaSyBxrJAxe69t02jMZKtOGXY3gCIgVm8RAMY"}):
+            with patch("langchain_openai.ChatOpenAI") as mock_llm:
+                mock_llm.return_value = Mock()
+                self.agent = initialize_agent()
+
+    def test_agent_has_all_tools_registered(self):
+        expected = {
+            "code_analysis",
+            "get_revenue_variance",
+            "get_gross_margin_pct",
+            "get_opex_breakdown",
+            "get_ebitda_proxy",
+            "get_cash_runway",
+            "plot_chart"
+        }
+        actual = {tool.name for tool in self.agent.tools}
+        assert expected == actual

tests/test_3.py

@@ -0,0 +1,25 @@
+# tests/test_agent_tool_selection_by_log.py
+import pytest
+from agent.agent import initialize_agent
+from unittest.mock import patch, Mock
+
+@pytest.fixture(autouse=True)
+def agent_executor():
+    # Create an agent with a dummy LLM but real logging of tool calls
+    with patch("streamlit.secrets", {"GOOGLE_API_KEY": "AIzaSyBxrJAxe69t02jMZKtOGXY3gCIgVm8RAMY"}):
+        with patch("langchain_openai.ChatOpenAI") as mock_llm:
+            mock_llm.return_value = Mock()
+            yield initialize_agent()
+
+@pytest.mark.parametrize("query,tool_name", [
+    ("What is revenue variance for January 2025?", "get_revenue_variance"),
+    ("What is our cash runway for 2025?",        "get_cash_runway"),
+    ("Show me gross margin percentage for July 2025", "get_gross_margin_pct"),
+    ("Break down opex by category for 2025",     "get_opex_breakdown"),
+    ("What's our EBITDA right now for last 3 months?", "get_ebitda_proxy"),
+])
+def test_tool_selected_in_logs(agent_executor, capsys, query, tool_name):
+    # Run the agent; it will print "Invoking: `tool_name` with ..."
+    agent_executor({"input": query})
+    captured = capsys.readouterr().out
+    assert f"Invoking: `{tool_name}`" in captured