kensho-kfinance 3.2.4__py3-none-any.whl → 4.0.0__py3-none-any.whl

kfinance/domains/line_items/tests/test_line_item_tools.py

@@ -1,22 +1,39 @@
+from decimal import Decimal
+
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from requests_mock import Mocker
 
 from kfinance.client.kfinance import Client
-from kfinance.conftest import SPGI_COMPANY_ID
 from kfinance.domains.companies.company_models import COMPANY_ID_PREFIX
+from kfinance.domains.line_items.line_item_models import LineItemResp, LineItemScore
 from kfinance.domains.line_items.line_item_tools import (
     GetFinancialLineItemFromIdentifiers,
     GetFinancialLineItemFromIdentifiersArgs,
+    GetFinancialLineItemFromIdentifiersResp,
+    _find_similar_line_items,
 )
 
 
 class TestGetFinancialLineItemFromCompanyIds:
     line_item_resp = {
-        "line_item": {
-            "2022": "11181000000.000000",
-            "2023": "12497000000.000000",
-            "2024": "14208000000.000000",
-        }
+        "currency": "USD",
+        "periods": {
+            "CY2022": {
+                "period_end_date": "2022-12-31",
+                "num_months": 12,
+                "line_item": {"name": "Revenue", "value": "11181000000.0", "sources": []},
+            },
+            "CY2023": {
+                "period_end_date": "2023-12-31",
+                "num_months": 12,
+                "line_item": {"name": "Revenue", "value": "12497000000.0", "sources": []},
+            },
+            "CY2024": {
+                "period_end_date": "2024-12-31",
+                "num_months": 12,
+                "line_item": {"name": "Revenue", "value": "14208000000.0", "sources": []},
+            },
+        },
     }
 
     def test_get_financial_line_item_from_identifiers(
@@ -28,36 +45,72 @@ class TestGetFinancialLineItemFromCompanyIds:
         THEN we get back the SPGI revenue and an error for the non-existent company
         """
 
-        expected_response = {
-            "SPGI": {
-                "2022": {"revenue": 11181000000.0},
-                "2023": {"revenue": 12497000000.0},
-                "2024": {"revenue": 14208000000.0},
-            }
-        }
-        expected_response = {
-            "results": {
-                "SPGI": {
-                    "line_item": {
-                        "2022": "11181000000.000000",
-                        "2023": "12497000000.000000",
-                        "2024": "14208000000.000000",
-                    }
-                }
+        expected_response = GetFinancialLineItemFromIdentifiersResp(
+            results={
+                "SPGI": LineItemResp(
+                    currency="USD",
+                    periods={
+                        "CY2022": {
+                            "period_end_date": "2022-12-31",
+                            "num_months": 12,
+                            "line_item": {
+                                "name": "Revenue",
+                                "value": Decimal(11181000000),
+                                "sources": [],
+                            },
+                        },
+                        "CY2023": {
+                            "period_end_date": "2023-12-31",
+                            "num_months": 12,
+                            "line_item": {
+                                "name": "Revenue",
+                                "value": Decimal(12497000000),
+                                "sources": [],
+                            },
+                        },
+                        "CY2024": {
+                            "period_end_date": "2024-12-31",
+                            "num_months": 12,
+                            "line_item": {
+                                "name": "Revenue",
+                                "value": Decimal(14208000000),
+                                "sources": [],
+                            },
+                        },
+                    },
+                )
             },
-            "errors": [
+            errors=[
                 "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
             ],
-        }
+        )
+
+        # Mock the unified_fetch_id_triples response
+        requests_mock.post(
+            url="https://kfinance.kensho.com/api/v1/ids",
+            json={
+                "identifiers_to_id_triples": {
+                    "SPGI": {
+                        "company_id": 21719,
+                        "security_id": 2629107,
+                        "trading_item_id": 2629108,
+                    }
+                },
+                "errors": {
+                    "NON-EXISTENT": "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
+                },
+            },
+        )
 
-        requests_mock.get(
-            url=f"https://kfinance.kensho.com/api/v1/line_item/{SPGI_COMPANY_ID}/revenue/none/none/none/none/none",
-            json=self.line_item_resp,
+        # Mock the fetch_line_item response
+        requests_mock.post(
+            url="https://kfinance.kensho.com/api/v1/line_item/",
+            json={"results": {"21719": self.line_item_resp}, "errors": {}},
         )
 
         tool = GetFinancialLineItemFromIdentifiers(kfinance_client=mock_client)
         args = GetFinancialLineItemFromIdentifiersArgs(
-            identifiers=["SPGI", "non-existent"], line_item="revenue"
+            identifiers=["SPGI", "NON-EXISTENT"], line_item="revenue"
         )
         response = tool.run(args.model_dump(mode="json"))
         assert response == expected_response
@@ -70,17 +123,93 @@ class TestGetFinancialLineItemFromCompanyIds:
         """
 
         company_ids = [1, 2]
-        expected_response = {
-            "results": {
-                "C_1": {"line_item": {"2024": "14208000000.000000"}},
-                "C_2": {"line_item": {"2024": "14208000000.000000"}},
-            }
-        }
-        for company_id in company_ids:
-            requests_mock.get(
-                url=f"https://kfinance.kensho.com/api/v1/line_item/{company_id}/revenue/none/none/none/none/none",
-                json=self.line_item_resp,
-            )
+
+        line_item_resp = LineItemResp(
+            currency="USD",
+            periods={
+                "CY2024": {
+                    "period_end_date": "2024-12-31",
+                    "num_months": 12,
+                    "line_item": {"name": "Revenue", "value": Decimal(14208000000), "sources": []},
+                }
+            },
+        )
+        expected_response = GetFinancialLineItemFromIdentifiersResp(
+            results={"C_1": line_item_resp, "C_2": line_item_resp},
+        )
+
+        # Mock the unified_fetch_id_triples response
+        requests_mock.post(
+            url="https://kfinance.kensho.com/api/v1/ids",
+            json={
+                "identifiers_to_id_triples": {
+                    "C_1": {"company_id": 1, "security_id": 101, "trading_item_id": 201},
+                    "C_2": {"company_id": 2, "security_id": 102, "trading_item_id": 202},
+                },
+                "errors": {},
+            },
+        )
+
+        # Mock the fetch_line_item response
+        requests_mock.post(
+            url="https://kfinance.kensho.com/api/v1/line_item/",
+            json={"results": {"1": self.line_item_resp, "2": self.line_item_resp}, "errors": {}},
+        )
+
+        tool = GetFinancialLineItemFromIdentifiers(kfinance_client=mock_client)
+        args = GetFinancialLineItemFromIdentifiersArgs(
+            identifiers=[f"{COMPANY_ID_PREFIX}{company_id}" for company_id in company_ids],
+            line_item="revenue",
+        )
+        response = tool.run(args.model_dump(mode="json"))
+        assert response == expected_response
+
+    def test_empty_most_recent_request(self, requests_mock: Mocker, mock_client: Client) -> None:
+        """
+        GIVEN the GetFinancialLineItemFromIdentifiers tool
+        WHEN we request most recent line items for multiple companies
+        THEN we only get back the most recent line item for each company
+        UNLESS no line items exist
+        """
+
+        company_ids = [1, 2]
+
+        c_1_line_item_resp = LineItemResp(currency="USD", periods={})
+        c_2_line_item_resp = LineItemResp(
+            currency="USD",
+            periods={
+                "CY2024": {
+                    "period_end_date": "2024-12-31",
+                    "num_months": 12,
+                    "line_item": {"name": "Revenue", "value": Decimal(14208000000), "sources": []},
+                }
+            },
+        )
+        expected_response = GetFinancialLineItemFromIdentifiersResp(
+            results={"C_1": c_1_line_item_resp, "C_2": c_2_line_item_resp},
+        )
+
+        # Mock the unified_fetch_id_triples response
+        requests_mock.post(
+            url="https://kfinance.kensho.com/api/v1/ids",
+            json={
+                "identifiers_to_id_triples": {
+                    "C_1": {"company_id": 1, "security_id": 101, "trading_item_id": 201},
+                    "C_2": {"company_id": 2, "security_id": 102, "trading_item_id": 202},
+                },
+                "errors": {},
+            },
+        )
+
+        # Mock the fetch_line_item response with different data for different companies
+        requests_mock.post(
+            url="https://kfinance.kensho.com/api/v1/line_item/",
+            json={
+                "results": {"1": {"currency": "USD", "periods": {}}, "2": self.line_item_resp},
+                "errors": {},
+            },
+        )
+
         tool = GetFinancialLineItemFromIdentifiers(kfinance_client=mock_client)
         args = GetFinancialLineItemFromIdentifiersArgs(
             identifiers=[f"{COMPANY_ID_PREFIX}{company_id}" for company_id in company_ids],
@@ -102,3 +231,140 @@ class TestGetFinancialLineItemFromCompanyIds:
         assert "revenue" in line_items
         # normal_revenue is an alias for revenue
         assert "normal_revenue" in line_items
+
+
+class TestFindSimilarLineItems:
+    """Tests for the _find_similar_line_items function."""
+
+    # Preset test descriptors to ensure consistent results
+    TEST_DESCRIPTORS = {
+        "revenue": "Revenue recognized from primary business activities (excludes non-operating income).",
+        "total_revenue": "Sum of operating and non-operating revenue streams for the period.",
+        "cost_of_goods_sold": "Direct costs attributable to producing goods sold during the period.",
+        "cogs": "Direct costs attributable to producing goods sold during the period.",
+        "gross_profit": "Revenue minus cost_of_goods_sold or cost_of_revenue for the reported period.",
+        "operating_income": "Operating profit after subtracting operating expenses from operating revenue.",
+        "net_income": "Bottom-line profit attributable to common shareholders.",
+        "research_and_development_expense": "Expenses incurred for research and development activities.",
+        "r_and_d_expense": "Expenses incurred for research and development activities.",
+        "depreciation_and_amortization": "Combined depreciation and amortization expense for the period.",
+        "ebitda": "Earnings before interest, taxes, depreciation, and amortization.",
+    }
+
+    def test_exact_keyword_match(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for 'revenues' (similar to 'revenue')
+        THEN 'revenue' should be in the top suggestions
+        """
+        results = _find_similar_line_items("revenues", self.TEST_DESCRIPTORS, max_suggestions=5)
+
+        assert len(results) > 0
+        assert isinstance(results[0], LineItemScore)
+        # Check that revenue or total_revenue is in top results
+        result_names = [item.name for item in results]
+        assert "revenue" in result_names or "total_revenue" in result_names
+
+    def test_acronym_matching(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for 'R&D' (abbreviation)
+        THEN research and development related items should appear
+        """
+        results = _find_similar_line_items("R&D", self.TEST_DESCRIPTORS, max_suggestions=5)
+
+        result_names = [item.name for item in results]
+        # Should find r_and_d_expense or research_and_development_expense
+        assert any("research" in name or "r_and_d" in name for name in result_names)
+
+    def test_multiple_word_matching(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for 'cost goods'
+        THEN 'cost_of_goods_sold' should be suggested
+        """
+        results = _find_similar_line_items("cost goods", self.TEST_DESCRIPTORS, max_suggestions=5)
+
+        result_names = [item.name for item in results]
+        assert "cost_of_goods_sold" in result_names or "cogs" in result_names
+
+    def test_description_matching(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for 'profit'
+        THEN items with 'profit' in description should appear
+        """
+        results = _find_similar_line_items("profit", self.TEST_DESCRIPTORS, max_suggestions=5)
+
+        assert len(results) > 0
+        # Should find items like gross_profit, operating_income (operating profit), or net_income
+        result_names = [item.name for item in results]
+        assert any("profit" in name or "income" in name for name in result_names)
+
+    def test_empty_descriptors(self):
+        """
+        GIVEN an empty descriptors dictionary
+        WHEN searching for any term
+        THEN should return empty list
+        """
+        results = _find_similar_line_items("revenue", {}, max_suggestions=5)
+        assert results == []
+
+    def test_no_matches(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for completely unrelated term
+        THEN should return empty list or very low scores filtered out
+        """
+        results = _find_similar_line_items("xyz123abc", self.TEST_DESCRIPTORS, max_suggestions=5)
+        # Should return empty or very few results since threshold is > 0.1
+        assert len(results) <= 2  # May have some weak matches but should be minimal
+
+    def test_max_suggestions_respected(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching with max_suggestions=3
+        THEN should return at most 3 results
+        """
+        results = _find_similar_line_items("income", self.TEST_DESCRIPTORS, max_suggestions=3)
+        assert len(results) <= 3
+
+    def test_score_ordering(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for a term
+        THEN results should be ordered by descending score
+        """
+        results = _find_similar_line_items("revenue", self.TEST_DESCRIPTORS, max_suggestions=5)
+
+        if len(results) > 1:
+            for i in range(len(results) - 1):
+                assert results[i].score >= results[i + 1].score
+
+    def test_score_threshold(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for a term
+        THEN all returned results should have score > 0.1
+        """
+        results = _find_similar_line_items("revenue", self.TEST_DESCRIPTORS, max_suggestions=10)
+
+        for item in results:
+            assert item.score > 0.1
+
+    def test_lineitemscore_structure(self):
+        """
+        GIVEN a preset descriptors dictionary
+        WHEN searching for a term
+        THEN each result should be a LineItemScore with name, description, and score
+        """
+        results = _find_similar_line_items("revenue", self.TEST_DESCRIPTORS, max_suggestions=5)
+
+        assert len(results) > 0
+        for item in results:
+            assert isinstance(item, LineItemScore)
+            assert isinstance(item.name, str)
+            assert isinstance(item.description, str)
+            assert isinstance(item.score, float)
+            assert item.name in self.TEST_DESCRIPTORS
+            assert item.description == self.TEST_DESCRIPTORS[item.name]

kfinance/domains/mergers_and_acquisitions/merger_and_acquisition_models.py

@@ -1,6 +1,9 @@
 from datetime import date
+from decimal import Decimal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, field_serializer
+
+from kfinance.domains.companies.company_models import COMPANY_ID_PREFIX, CompanyIdAndName
 
 
 class MergerSummary(BaseModel):
@@ -16,6 +19,47 @@ class MergersResp(BaseModel):
 
 
 class AdvisorResp(BaseModel):
-    advisor_company_id: str
+    advisor_company_id: int
     advisor_company_name: str
     advisor_type_name: str | None
+
+    @field_serializer("advisor_company_id")
+    def serialize_with_prefix(self, company_id: int) -> str:
+        """Serialize the advisor_company_id with a prefix ("C_<company_id>").
+
+        Including the prefix allows us to distinguish tickers and company_ids.
+        """
+        return f"{COMPANY_ID_PREFIX}{company_id}"
+
+
+class MergerTimelineElement(BaseModel):
+    status: str
+    date: date
+
+
+class MergerParticipants(BaseModel):
+    target: CompanyIdAndName
+    buyers: list[CompanyIdAndName]
+    sellers: list[CompanyIdAndName]
+
+
+class MergerConsiderationDetail(BaseModel):
+    scenario: str | None = None
+    subtype: str | None = None
+    cash_or_cash_equivalent_per_target_share_unit: Decimal | None = None
+    number_of_target_shares_sought: Decimal | None = None
+    current_calculated_gross_value_of_consideration: Decimal | None = None
+
+
+class MergerConsideration(BaseModel):
+    currency_name: str | None = None
+    current_calculated_gross_total_transaction_value: Decimal | None = None
+    current_calculated_implied_equity_value: Decimal | None = None
+    current_calculated_implied_enterprise_value: Decimal | None = None
+    details: list[MergerConsiderationDetail]
+
+
+class MergerInfo(BaseModel):
+    timeline: list[MergerTimelineElement]
+    participants: MergerParticipants
+    consideration: MergerConsideration

kfinance/domains/mergers_and_acquisitions/merger_and_acquisition_tools.py

@@ -4,11 +4,11 @@ from typing import Type
 from pydantic import BaseModel, Field
 
 from kfinance.client.batch_request_handling import Task, process_tasks_in_thread_pool_executor
-from kfinance.client.kfinance import Company, MergerOrAcquisition, ParticipantInMerger
+from kfinance.client.kfinance import Company, ParticipantInMerger
 from kfinance.client.permission_models import Permission
-from kfinance.domains.companies.company_models import prefix_company_id
 from kfinance.domains.mergers_and_acquisitions.merger_and_acquisition_models import (
     AdvisorResp,
+    MergerInfo,
     MergersResp,
 )
 from kfinance.integrations.tool_calling.tool_calling_models import (
@@ -26,12 +26,24 @@ class GetMergersFromIdentifiersResp(ToolRespWithErrors):
 class GetMergersFromIdentifiers(KfinanceTool):
     name: str = "get_mergers_from_identifiers"
     description: str = dedent("""
-        "Retrieves all merger and acquisition transactions involving the specified company identifier for each specified company identifier. The results are categorized by the company's role in each transaction: target, buyer, or seller. Provides the transaction_id, merger_title, and transaction closed_date (finalization) . Use this tool to answer questions like 'Which companies did Microsoft purchase?', 'Which company acquired Ben & Jerry's?', and 'Who did Pfizer acquire?'"
+        Retrieves all merger and acquisition transactions involving the specified company.
+
+        Results are categorized by the company's role: target (being acquired), buyer (making the acquisition), or seller (divesting an asset).
+
+        - When possible, pass multiple identifiers in a single call rather than making multiple calls.
+        - Provides transaction_id, merger_title, and transaction closed_date.
+
+        Examples:
+        Query: "Which companies did Microsoft purchase?"
+        Function: get_mergers_from_identifiers(identifiers=["Microsoft"])
+
+        Query: "Get acquisitions for AAPL and GOOGL"
+        Function: get_mergers_from_identifiers(identifiers=["AAPL", "GOOGL"])
     """).strip()
     args_schema: Type[BaseModel] = ToolArgsWithIdentifiers
     accepted_permissions: set[Permission] | None = {Permission.MergersPermission}
 
-    def _run(self, identifiers: list[str]) -> dict:
+    def _run(self, identifiers: list[str]) -> GetMergersFromIdentifiersResp:
         """Sample Response:
 
         {
@@ -79,86 +91,46 @@ class GetMergersFromIdentifiers(KfinanceTool):
         merger_responses: dict[str, MergersResp] = process_tasks_in_thread_pool_executor(
             api_client=api_client, tasks=tasks
         )
-        output_model = GetMergersFromIdentifiersResp(
+        return GetMergersFromIdentifiersResp(
             results=merger_responses, errors=list(id_triple_resp.errors.values())
         )
-        return output_model.model_dump(mode="json")
 
 
 class GetMergerInfoFromTransactionIdArgs(BaseModel):
-    transaction_id: int | None = Field(description="The ID of the transaction.", default=None)
+    transaction_id: int | None = Field(description="The ID of the transaction.")
 
 
 class GetMergerInfoFromTransactionId(KfinanceTool):
     name: str = "get_merger_info_from_transaction_id"
     description: str = dedent("""
-        "Provides comprehensive information about a specific merger or acquisition transaction, including its timeline (announced date, closed date), participants' company_name and company_id (target, buyers, sellers), and financial consideration details (including monetary values). Use this tool to answer questions like 'When was the acquisition Ben & Jerry's announced?', 'What was the transaction size of Vodafone's acquisition of Mannesmann?', 'How much did S&P purchase Kensho for?'. Always call this for announcement related questions"
+        Provides comprehensive information about a specific merger or acquisition transaction, including its timeline (announced date, closed date), participants' company_name and company_id (target, buyers, sellers), and financial consideration details (including monetary values).
+
+        Use this tool for questions about announcement dates and transaction details.
+
+        Examples:
+        Query: "When was the acquisition of Ben & Jerry's announced?"
+        Function 1: get_mergers_from_identifiers(identifiers=["Ben & Jerry's"])
+        # Function 1 returns all M&A's that involved Ben & Jerry's. Extract the <key_dev_id> from the response where Ben & Jerry's was the target.
+        Function 2: get_merger_info_from_transaction_id(transaction_id=<key_dev_id>)
+
+        Query: "What was the transaction size of Vodafone's acquisition of Mannesmann?"
+        Function 1: get_mergers_from_identifiers(identifiers=["Vodafone"])
+        # Function 1 returns all M&A's that involved Vodafone. Extract the <key_dev_id> from the response where Vodafone was the buyer and Mannesmann was the target.
+        Function 2: get_merger_info_from_transaction_id(transaction_id=<key_dev_id>)
+
+
     """).strip()
     args_schema: Type[BaseModel] = GetMergerInfoFromTransactionIdArgs
     accepted_permissions: set[Permission] | None = {Permission.MergersPermission}
 
-    def _run(self, transaction_id: int) -> dict:
-        merger_or_acquisition = MergerOrAcquisition(
-            kfinance_api_client=self.kfinance_client.kfinance_api_client,
-            transaction_id=transaction_id,
-            merger_title=None,
-            closed_date=None,
+    def _run(self, transaction_id: int) -> MergerInfo:
+        return self.kfinance_client.kfinance_api_client.fetch_merger_info(
+            transaction_id=transaction_id
         )
-        merger_timeline = merger_or_acquisition.get_timeline
-        merger_participants = merger_or_acquisition.get_participants
-        merger_consideration = merger_or_acquisition.get_consideration
-
-        return {
-            "timeline": [
-                {"status": timeline["status"], "date": timeline["date"].strftime("%Y-%m-%d")}
-                for timeline in merger_timeline.to_dict(orient="records")
-            ]
-            if merger_timeline is not None
-            else None,
-            "participants": {
-                "target": {
-                    "company_id": prefix_company_id(
-                        merger_participants["target"].company.company_id
-                    ),
-                    "company_name": merger_participants["target"].company.name,
-                },
-                "buyers": [
-                    {
-                        "company_id": prefix_company_id(buyer.company.company_id),
-                        "company_name": buyer.company.name,
-                    }
-                    for buyer in merger_participants["buyers"]
-                ],
-                "sellers": [
-                    {
-                        "company_id": prefix_company_id(seller.company.company_id),
-                        "company_name": seller.company.name,
-                    }
-                    for seller in merger_participants["sellers"]
-                ],
-            }
-            if merger_participants is not None
-            else None,
-            "consideration": {
-                "currency_name": merger_consideration["currency_name"],
-                "current_calculated_gross_total_transaction_value": merger_consideration[
-                    "current_calculated_gross_total_transaction_value"
-                ],
-                "current_calculated_implied_equity_value": merger_consideration[
-                    "current_calculated_implied_equity_value"
-                ],
-                "current_calculated_implied_enterprise_value": merger_consideration[
-                    "current_calculated_implied_enterprise_value"
-                ],
-                "details": merger_consideration["details"].to_dict(orient="records"),
-            }
-            if merger_consideration is not None
-            else None,
-        }
 
 
 class GetAdvisorsForCompanyInTransactionFromIdentifierArgs(ToolArgsWithIdentifier):
-    transaction_id: int | None = Field(description="The ID of the merger.", default=None)
+    transaction_id: int | None = Field(description="The ID of the merger.")
 
 
 class GetAdvisorsForCompanyInTransactionFromIdentifierResp(ToolRespWithErrors):
@@ -166,22 +138,32 @@ class GetAdvisorsForCompanyInTransactionFromIdentifierResp(ToolRespWithErrors):
 
 
 class GetAdvisorsForCompanyInTransactionFromIdentifier(KfinanceTool):
-    name: str = "get_advisors_for_company_in_transaction_from_identifier"
+    name: str = "get_advisors_for_company_in_transaction"
     description: str = dedent("""
-        "Returns a list of advisor companies that provided advisory services to the specified company during a particular merger or acquisition transaction. Use this tool to answer questions like 'Who advised S&P Global during their purchase of Kensho?', 'Which firms advised Ben & Jerry's in their acquisition?'."
+        Returns a list of advisor companies that provided advisory services to the specified company during a particular merger or acquisition transaction.
+
+        Examples:
+        Query: "Who advised S&P Global during their purchase of Kensho?"
+        Function 1: get_mergers_from_identifiers(identifiers=["S&P Global"])
+        # Function 1 returns all M&A's that involved S&P Global. Extract the <key_dev_id> from the response where S&P Global was the buyer and Kensho was the target.
+        Function 2: get_advisors_for_company_in_transaction(identifier="S&P Global", transaction_id=<key_dev_id>)
+
+        Query: "Which firms advised AAPL in transaction 67890?"
+        Function: get_advisors_for_company_in_transaction(identifier="AAPL", transaction_id=67890)
     """).strip()
     args_schema: Type[BaseModel] = GetAdvisorsForCompanyInTransactionFromIdentifierArgs
     accepted_permissions: set[Permission] | None = {Permission.MergersPermission}
 
-    def _run(self, identifier: str, transaction_id: int) -> dict:
+    def _run(
+        self, identifier: str, transaction_id: int
+    ) -> GetAdvisorsForCompanyInTransactionFromIdentifierResp:
         api_client = self.kfinance_client.kfinance_api_client
         id_triple_resp = api_client.unified_fetch_id_triples(identifiers=[identifier])
         # If the identifier cannot be resolved, return the associated error.
         if id_triple_resp.errors:
-            output_model = GetAdvisorsForCompanyInTransactionFromIdentifierResp(
+            return GetAdvisorsForCompanyInTransactionFromIdentifierResp(
                 results=[], errors=list(id_triple_resp.errors.values())
             )
-            return output_model.model_dump(mode="json")
 
         id_triple = id_triple_resp.identifiers_to_id_triples[identifier]
 
@@ -201,13 +183,12 @@ class GetAdvisorsForCompanyInTransactionFromIdentifier(KfinanceTool):
             for advisor in advisors:
                 advisors_response.append(
                     AdvisorResp(
-                        advisor_company_id=prefix_company_id(advisor.company.company_id),
+                        advisor_company_id=advisor.company.company_id,
                         advisor_company_name=advisor.company.name,
                         advisor_type_name=advisor.advisor_type_name,
                     )
                 )
 
-        output_model = GetAdvisorsForCompanyInTransactionFromIdentifierResp(
+        return GetAdvisorsForCompanyInTransactionFromIdentifierResp(
             results=advisors_response, errors=list(id_triple_resp.errors.values())
         )
-        return output_model.model_dump(mode="json")