kensho-kfinance 3.2.5__py3-none-any.whl → 3.2.7__py3-none-any.whl

kfinance/domains/earnings/tests/test_earnings_tools.py

@@ -7,10 +7,13 @@ from kfinance.client.kfinance import Client
 from kfinance.conftest import SPGI_COMPANY_ID
 from kfinance.domains.earnings.earning_tools import (
     GetEarningsFromIdentifiers,
+    GetEarningsFromIdentifiersResp,
     GetLatestEarningsFromIdentifiers,
     GetNextEarningsFromIdentifiers,
+    GetNextOrLatestEarningsFromIdentifiersResp,
     GetTranscriptFromKeyDevId,
     GetTranscriptFromKeyDevIdArgs,
+    GetTranscriptFromKeyDevIdResp,
 )
 from kfinance.integrations.tool_calling.tool_calling_models import ToolArgsWithIdentifiers
 
@@ -43,27 +46,29 @@ class TestGetEarnings:
             json=self.earnings_response,
         )
 
-        expected_response = {
-            "results": {
-                "SPGI": {
-                    "earnings_calls": [
-                        {
-                            "name": "SPGI Q1 2025 Earnings Call",
-                            "key_dev_id": 12346,
-                            "datetime": "2025-04-29T12:30:00Z",
-                        },
-                        {
-                            "name": "SPGI Q4 2024 Earnings Call",
-                            "key_dev_id": 12345,
-                            "datetime": "2025-02-11T13:30:00Z",
-                        },
-                    ]
-                }
-            },
-            "errors": [
-                "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
-            ],
-        }
+        expected_response = GetEarningsFromIdentifiersResp.model_validate(
+            {
+                "results": {
+                    "SPGI": {
+                        "earnings": [
+                            {
+                                "name": "SPGI Q1 2025 Earnings Call",
+                                "key_dev_id": 12346,
+                                "datetime": "2025-04-29T12:30:00Z",
+                            },
+                            {
+                                "name": "SPGI Q4 2024 Earnings Call",
+                                "key_dev_id": 12345,
+                                "datetime": "2025-02-11T13:30:00Z",
+                            },
+                        ]
+                    }
+                },
+                "errors": [
+                    "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
+                ],
+            }
+        )
 
         tool = GetEarningsFromIdentifiers(kfinance_client=mock_client)
         response = tool.run(
@@ -95,16 +100,18 @@ class TestGetEarnings:
             json={"earnings": []},
         )
 
-        expected_response = {
-            "results": {
-                "SPGI": {
-                    "name": "SPGI Q1 2025 Earnings Call",
-                    "key_dev_id": 12346,
-                    "datetime": "2025-04-29T12:30:00Z",
-                }
-            },
-            "errors": ["No latest earnings available for private_company."],
-        }
+        expected_response = GetNextOrLatestEarningsFromIdentifiersResp.model_validate(
+            {
+                "results": {
+                    "SPGI": {
+                        "name": "SPGI Q1 2025 Earnings Call",
+                        "key_dev_id": 12346,
+                        "datetime": "2025-04-29T12:30:00Z",
+                    }
+                },
+                "errors": ["No latest earnings available for private_company."],
+            }
+        )
 
         tool = GetLatestEarningsFromIdentifiers(kfinance_client=mock_client)
         response = tool.run(
@@ -136,16 +143,18 @@ class TestGetEarnings:
             json={"earnings": []},
         )
 
-        expected_response = {
-            "results": {
-                "SPGI": {
-                    "datetime": "2025-04-29T12:30:00Z",
-                    "key_dev_id": 12346,
-                    "name": "SPGI Q1 2025 Earnings Call",
-                }
-            },
-            "errors": ["No next earnings available for private_company."],
-        }
+        expected_response = GetNextOrLatestEarningsFromIdentifiersResp.model_validate(
+            {
+                "results": {
+                    "SPGI": {
+                        "datetime": "2025-04-29T12:30:00Z",
+                        "key_dev_id": 12346,
+                        "name": "SPGI Q1 2025 Earnings Call",
+                    }
+                },
+                "errors": ["No next earnings available for private_company."],
+            }
+        )
 
         tool = GetNextEarningsFromIdentifiers(kfinance_client=mock_client)
         response = tool.run(
@@ -181,8 +190,8 @@ class TestGetTranscript:
             json=transcript_data,
         )
 
-        expected_response = (
-            "Operator: Good morning, everyone.\n\nCEO: Thank you for joining us today."
+        expected_response = GetTranscriptFromKeyDevIdResp(
+            transcript="Operator: Good morning, everyone.\n\nCEO: Thank you for joining us today."
         )
 
         tool = GetTranscriptFromKeyDevId(kfinance_client=mock_client)

kfinance/domains/line_items/line_item_tools.py

@@ -63,7 +63,7 @@ class GetFinancialLineItemFromIdentifiers(KfinanceTool):
         end_year: int | None = None,
         start_quarter: Literal[1, 2, 3, 4] | None = None,
         end_quarter: Literal[1, 2, 3, 4] | None = None,
-    ) -> dict:
+    ) -> GetFinancialLineItemFromIdentifiersResp:
         """Sample response:
 
         {
@@ -113,7 +113,6 @@ class GetFinancialLineItemFromIdentifiers(KfinanceTool):
                 most_recent_year_data = line_item_response.line_item[most_recent_year]
                 line_item_response.line_item = {most_recent_year: most_recent_year_data}
 
-        output_model = GetFinancialLineItemFromIdentifiersResp(
+        return GetFinancialLineItemFromIdentifiersResp(
             results=line_item_responses, errors=list(id_triple_resp.errors.values())
         )
-        return output_model.model_dump(mode="json")

kfinance/domains/line_items/tests/test_line_item_tools.py

@@ -1,12 +1,16 @@
+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 LineItemResponse
 from kfinance.domains.line_items.line_item_tools import (
     GetFinancialLineItemFromIdentifiers,
     GetFinancialLineItemFromIdentifiersArgs,
+    GetFinancialLineItemFromIdentifiersResp,
 )
 
 
@@ -28,27 +32,20 @@ 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": LineItemResponse(
+                    line_item={
+                        "2022": Decimal(11181000000),
+                        "2023": Decimal(12497000000),
+                        "2024": Decimal(14208000000),
                     }
-                }
+                )
             },
-            "errors": [
+            errors=[
                 "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",
@@ -70,12 +67,12 @@ class TestGetFinancialLineItemFromCompanyIds:
         """
 
         company_ids = [1, 2]
-        expected_response = {
-            "results": {
-                "C_1": {"line_item": {"2024": "14208000000.000000"}},
-                "C_2": {"line_item": {"2024": "14208000000.000000"}},
-            }
-        }
+
+        line_item_resp = LineItemResponse(line_item={"2024": Decimal(14208000000)})
+        expected_response = GetFinancialLineItemFromIdentifiersResp(
+            results={"C_1": line_item_resp, "C_2": line_item_resp},
+        )
+
         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",

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 (
@@ -31,7 +31,7 @@ class GetMergersFromIdentifiers(KfinanceTool):
     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,10 +79,9 @@ 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):
@@ -97,64 +96,10 @@ class GetMergerInfoFromTransactionId(KfinanceTool):
     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):
@@ -173,15 +118,16 @@ class GetAdvisorsForCompanyInTransactionFromIdentifier(KfinanceTool):
     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 +147,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")

kfinance/domains/mergers_and_acquisitions/tests/test_merger_and_acquisition_tools.py

@@ -8,13 +8,18 @@ from kfinance.client.tests.test_objects import (
     ordered,
 )
 from kfinance.conftest import SPGI_COMPANY_ID
-from kfinance.domains.companies.company_models import COMPANY_ID_PREFIX
+from kfinance.domains.mergers_and_acquisitions.merger_and_acquisition_models import (
+    AdvisorResp,
+    MergerInfo,
+)
 from kfinance.domains.mergers_and_acquisitions.merger_and_acquisition_tools import (
     GetAdvisorsForCompanyInTransactionFromIdentifier,
     GetAdvisorsForCompanyInTransactionFromIdentifierArgs,
+    GetAdvisorsForCompanyInTransactionFromIdentifierResp,
     GetMergerInfoFromTransactionId,
     GetMergerInfoFromTransactionIdArgs,
     GetMergersFromIdentifiers,
+    GetMergersFromIdentifiersResp,
 )
 from kfinance.integrations.tool_calling.tool_calling_models import ToolArgsWithIdentifiers
 
@@ -27,12 +32,14 @@ class TestGetMergersFromIdentifiers:
         THEN we get back the SPGI mergers and an error for the non-existent company"""
 
         merger_data = MERGERS_RESP.model_dump(mode="json")
-        expected_response = {
-            "results": {"SPGI": merger_data},
-            "errors": [
-                "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
-            ],
-        }
+        expected_response = GetMergersFromIdentifiersResp.model_validate(
+            {
+                "results": {"SPGI": merger_data},
+                "errors": [
+                    "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
+                ],
+            }
+        )
         requests_mock.get(
             url=f"https://kfinance.kensho.com/api/v1/mergers/{SPGI_COMPANY_ID}", json=merger_data
         )
@@ -51,13 +58,21 @@ class TestGetCompaniesAdvisingCompanyInTransactionFromIdentifier:
             "advisor_company_name": "Kensho Technologies, Inc.",
             "advisor_type_name": "Professional Mongo Enjoyer",
         }
-        api_response = {"advisors": [deepcopy(advisor_data)]}
-        expected_response = {"results": [deepcopy(advisor_data)]}
-        expected_response["results"][0]["advisor_company_id"] = f"{COMPANY_ID_PREFIX}251994106"
+        expected_response = GetAdvisorsForCompanyInTransactionFromIdentifierResp(
+            results=[
+                AdvisorResp(
+                    advisor_company_id=251994106,
+                    advisor_company_name="Kensho Technologies, Inc.",
+                    advisor_type_name="Professional Mongo Enjoyer",
+                )
+            ],
+            errors=[],
+        )
+
         transaction_id = 554979212
         requests_mock.get(
             url=f"https://kfinance.kensho.com/api/v1/merger/info/{transaction_id}/advisors/{SPGI_COMPANY_ID}",
-            json=api_response,
+            json={"advisors": [deepcopy(advisor_data)]},
         )
         tool = GetAdvisorsForCompanyInTransactionFromIdentifier(kfinance_client=mock_client)
         args = GetAdvisorsForCompanyInTransactionFromIdentifierArgs(
@@ -67,14 +82,14 @@ class TestGetCompaniesAdvisingCompanyInTransactionFromIdentifier:
         assert response == expected_response
 
     def test_get_companies_advising_company_in_transaction_from_bad_identifier(
-        self, requests_mock: Mocker, mock_client: Client
+        self, mock_client: Client
     ):
-        expected_response = {
-            "results": [],
-            "errors": [
+        expected_response = GetAdvisorsForCompanyInTransactionFromIdentifierResp(
+            results=[],
+            errors=[
                 "No identification triple found for the provided identifier: NON-EXISTENT of type: ticker"
             ],
-        }
+        )
         transaction_id = 554979212
         tool = GetAdvisorsForCompanyInTransactionFromIdentifier(kfinance_client=mock_client)
         args = GetAdvisorsForCompanyInTransactionFromIdentifierArgs(
@@ -86,30 +101,11 @@ class TestGetCompaniesAdvisingCompanyInTransactionFromIdentifier:
 
 class TestGetMergerInfoFromTransactionId:
     def test_get_merger_info_from_transaction_id(self, requests_mock: Mocker, mock_client: Client):
-        response_base = {
-            "timeline": [
-                {"status": "Announced", "date": "2000-09-12"},
-                {"status": "Closed", "date": "2000-09-12"},
-            ],
-            "participants": {},
-            "consideration": {
-                "currency_name": "US Dollar",
-                "current_calculated_gross_total_transaction_value": "51609375.000000",
-                "current_calculated_implied_equity_value": "51609375.000000",
-                "current_calculated_implied_enterprise_value": "51609375.000000",
-                "details": [
-                    {
-                        "scenario": "Stock Lump Sum",
-                        "subtype": "Common Equity",
-                        "cash_or_cash_equivalent_per_target_share_unit": None,
-                        "number_of_target_shares_sought": "1000000.000000",
-                        "current_calculated_gross_value_of_consideration": "51609375.000000",
-                    }
-                ],
-            },
-        }
-
-        participants_api_response = {
+        timeline_resp = [
+            {"status": "Announced", "date": "2000-09-12"},
+            {"status": "Closed", "date": "2000-09-12"},
+        ]
+        participants_resp = {
             "target": {"company_id": 31696, "company_name": "MongoMusic, Inc."},
             "buyers": [{"company_id": 21835, "company_name": "Microsoft Corporation"}],
             "sellers": [
@@ -117,33 +113,39 @@ class TestGetMergerInfoFromTransactionId:
                 {"company_id": 20087, "company_name": "Draper Richards, L.P."},
             ],
         }
-        api_response = deepcopy(response_base)
-        api_response["participants"] = participants_api_response
 
-        # Returned company IDs should be prefixed
-        expected_participants_tool_response = {
-            "target": {
-                "company_id": f"{COMPANY_ID_PREFIX}31696",
-                "company_name": "MongoMusic, Inc.",
-            },
-            "buyers": [
-                {"company_id": f"{COMPANY_ID_PREFIX}21835", "company_name": "Microsoft Corporation"}
-            ],
-            "sellers": [
-                {"company_id": f"{COMPANY_ID_PREFIX}18805", "company_name": "Angel Investors L.P."},
+        consideration_resp = {
+            "currency_name": "US Dollar",
+            "current_calculated_gross_total_transaction_value": "51609375.000000",
+            "current_calculated_implied_equity_value": "51609375.000000",
+            "current_calculated_implied_enterprise_value": "51609375.000000",
+            "details": [
                 {
-                    "company_id": f"{COMPANY_ID_PREFIX}20087",
-                    "company_name": "Draper Richards, L.P.",
-                },
+                    "scenario": "Stock Lump Sum",
+                    "subtype": "Common Equity",
+                    "cash_or_cash_equivalent_per_target_share_unit": None,
+                    "number_of_target_shares_sought": "1000000.000000",
+                    "current_calculated_gross_value_of_consideration": "51609375.000000",
+                }
             ],
         }
-        expected_response = deepcopy(response_base)
-        expected_response["participants"] = expected_participants_tool_response
+
+        expected_response = MergerInfo.model_validate(
+            {
+                "timeline": timeline_resp,
+                "participants": participants_resp,
+                "consideration": consideration_resp,
+            }
+        )
 
         transaction_id = 517414
         requests_mock.get(
             url=f"https://kfinance.kensho.com/api/v1/merger/info/{transaction_id}",
-            json=api_response,
+            json={
+                "timeline": timeline_resp,
+                "participants": participants_resp,
+                "consideration": consideration_resp,
+            },
         )
         tool = GetMergerInfoFromTransactionId(kfinance_client=mock_client)
         args = GetMergerInfoFromTransactionIdArgs(transaction_id=transaction_id)

kfinance/domains/prices/price_tools.py

@@ -60,7 +60,7 @@ class GetPricesFromIdentifiers(KfinanceTool):
         end_date: date | None = None,
         periodicity: Periodicity = Periodicity.day,
         adjusted: bool = True,
-    ) -> dict:
+    ) -> GetPricesFromIdentifiersResp:
         """Sample Response:
 
         {
@@ -116,10 +116,9 @@ class GetPricesFromIdentifiers(KfinanceTool):
             for price_response in price_responses.values():
                 price_response.prices = price_response.prices[-1:]
 
-        output_model = GetPricesFromIdentifiersResp(
+        return GetPricesFromIdentifiersResp(
             results=price_responses, errors=list(id_triple_resp.errors.values())
         )
-        return output_model.model_dump(mode="json")
 
 
 class GetHistoryMetadataFromIdentifiersResp(ToolRespWithErrors):
@@ -136,7 +135,7 @@ class GetHistoryMetadataFromIdentifiers(KfinanceTool):
     args_schema: Type[BaseModel] = ToolArgsWithIdentifiers
     accepted_permissions: set[Permission] | None = None
 
-    def _run(self, identifiers: list[str]) -> dict:
+    def _run(self, identifiers: list[str]) -> GetHistoryMetadataFromIdentifiersResp:
         """Sample response:
 
         {
@@ -169,8 +168,6 @@ class GetHistoryMetadataFromIdentifiers(KfinanceTool):
         history_metadata_responses: dict[str, HistoryMetadataResp] = (
             process_tasks_in_thread_pool_executor(api_client=api_client, tasks=tasks)
         )
-        output_model = GetHistoryMetadataFromIdentifiersResp(
+        return GetHistoryMetadataFromIdentifiersResp(
             results=history_metadata_responses, errors=list(id_triple_resp.errors.values())
         )
-
-        return output_model.model_dump(mode="json")