payi 0.1.0a83__py3-none-any.whl → 0.1.0a84__py3-none-any.whl

payi/lib/GoogleGenAiInstrumentor.py

@@ -1,12 +1,10 @@
 import json
-import math
 from typing import Any, List, Union, Optional, Sequence
 from typing_extensions import override
 
 from wrapt import wrap_function_wrapper  # type: ignore
 
 from payi.lib.helpers import PayiCategories
-from payi.types.ingest_units_params import Units
 
 from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
 
@@ -115,9 +113,6 @@ async def agenerate_stream_wrapper(
         kwargs,
     )
 
-def count_chars_skip_spaces(text: str) -> int:
-    return sum(1 for c in text if not c.isspace())
-
 class _GoogleGenAiRequest(_ProviderRequest):
     def __init__(self, instrumentor: _PayiInstrumentor):
         super().__init__(
@@ -126,7 +121,7 @@ class _GoogleGenAiRequest(_ProviderRequest):
             streaming_type=_StreamingType.generator,
             )
         self._prompt_character_count = 0
-        self._candiates_character_count = 0
+        self._candidates_character_count = 0
 
     @override
     def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
@@ -158,6 +153,8 @@ class _GoogleGenAiRequest(_ProviderRequest):
         if isinstance(value, list):
             items = value # type: ignore
 
+        from .VertexInstrumentor import count_chars_skip_spaces
+
         for item in items: # type: ignore
             text = ""
             if isinstance(item, Part):
@@ -249,6 +246,8 @@ class _GoogleGenAiRequest(_ProviderRequest):
 
     @override
     def process_chunk(self, chunk: Any) -> _ChunkResult:
+        from .VertexInstrumentor import vertex_compute_usage, count_chars_skip_spaces
+
         ingest = False
         response_dict: dict[str, Any] = chunk.to_json_dict()
         if "provider_response_id" not in self._ingest:
@@ -260,22 +259,25 @@ class _GoogleGenAiRequest(_ProviderRequest):
 
         self._ingest["resource"] = "google." + model
 
+
         for candidate in response_dict.get("candidates", []):
             parts = candidate.get("content", {}).get("parts", [])
             for part in parts:
-                self._candiates_character_count += count_chars_skip_spaces(part.get("text", ""))
+                self._candidates_character_count += count_chars_skip_spaces(part.get("text", ""))
 
         usage = response_dict.get("usage_metadata", {})
         if usage and "prompt_token_count" in usage and "candidates_token_count" in usage:
-            self._compute_usage(response_dict, streaming_candidates_characters=self._candiates_character_count)
+            vertex_compute_usage(
+                request=self,
+                model=model,
+                response_dict=response_dict,
+                prompt_character_count=self._prompt_character_count,
+                streaming_candidates_characters=self._candidates_character_count
+                )
             ingest = True
 
         return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
     
-    @staticmethod
-    def _is_character_billing_model(model: str) -> bool:
-        return model.startswith("gemini-1.")
-    
     @override
     def process_synchronous_response(
         self,
@@ -284,6 +286,8 @@ class _GoogleGenAiRequest(_ProviderRequest):
         kwargs: Any) -> Any:
         response_dict = response.to_json_dict()
 
+        from .VertexInstrumentor import vertex_compute_usage
+
         id: Optional[str] = response_dict.get("response_id", None)
         if id:
             self._ingest["provider_response_id"] = id
@@ -292,105 +296,15 @@ class _GoogleGenAiRequest(_ProviderRequest):
         if model:
             self._ingest["resource"] = "google." + model
 
-        self._compute_usage(response_dict)
-        
+        vertex_compute_usage(
+            request=self,
+            model=model,
+            response_dict=response_dict,
+            prompt_character_count=self._prompt_character_count,
+            streaming_candidates_characters=self._candidates_character_count
+            )
+
         if log_prompt_and_response:
             self._ingest["provider_response_json"] = [json.dumps(response_dict)]
 
-        return None
-
-    def add_units(self, key: str, input: Optional[int] = None, output: Optional[int] = None) -> None:
-        if key not in self._ingest["units"]:
-            self._ingest["units"][key] = {}
-        if input is not None:
-            self._ingest["units"][key]["input"] = input
-        if output is not None:
-            self._ingest["units"][key]["output"] = output
-
-    def _compute_usage(self, response_dict: 'dict[str, Any]', streaming_candidates_characters: Optional[int] = None) -> None:
-        usage = response_dict.get("usage_metadata", {})
-        input = usage.get("prompt_token_count", 0)
-
-        prompt_tokens_details: list[dict[str, Any]] = usage.get("prompt_tokens_details", [])
-        candidates_tokens_details: list[dict[str, Any]] = usage.get("candidates_tokens_details", [])
-
-        model: str = response_dict.get("model_version", "")
-        
-        # for character billing only
-        large_context = "" if input < 128000 else "_large_context"
-
-        if self._is_character_billing_model(model):
-            for details in prompt_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality == "TEXT":
-                    input = self._prompt_character_count
-                    if input == 0:
-                        # back up calc if nothing was calculated from the prompt
-                        input = response_dict["usage_metadata"]["prompt_token_count"] * 4
-
-                    output = 0
-                    if streaming_candidates_characters is None:
-                        for candidate in response_dict.get("candidates", []):
-                            parts = candidate.get("content", {}).get("parts", [])
-                            for part in parts:
-                                output += count_chars_skip_spaces(part.get("text", ""))
-
-                        if output == 0:
-                            # back up calc if no parts
-                            output = response_dict["usage_metadata"]["candidates_token_count"] * 4
-                    else:
-                        output = streaming_candidates_characters
-
-                    self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
-
-                elif modality == "IMAGE":
-                    num_images = math.ceil(modality_token_count / 258)
-                    self.add_units("vision"+large_context, input=num_images)
-
-                elif modality == "VIDEO":
-                    video_seconds = math.ceil(modality_token_count / 285)
-                    self.add_units("video"+large_context, input=video_seconds)
-
-                elif modality == "AUDIO":
-                    audio_seconds = math.ceil(modality_token_count / 25)
-                    self.add_units("audio"+large_context, input=audio_seconds)
-
-        else:
-            for details in prompt_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality == "IMAGE":
-                    self.add_units("vision", input=modality_token_count)
-                elif modality in ("VIDEO", "AUDIO", "TEXT"):
-                    self.add_units(modality.lower(), input=modality_token_count)
-            for details in candidates_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality in ("VIDEO", "AUDIO", "TEXT", "IMAGE"):
-                    self.add_units(modality.lower(), output=modality_token_count)
-
-        if not self._ingest["units"]:
-            input = usage.get("prompt_token_count", 0)
-            output = usage.get("candidates_token_count", 0) * 4
-            
-            if self._is_character_billing_model(model):
-                if self._prompt_character_count > 0:
-                    input = self._prompt_character_count
-                else:
-                    input *= 4
-
-                # if no units were added, add a default unit and assume 4 characters per token
-                self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
-            else:
-                # if no units were added, add a default unit
-                self._ingest["units"]["text"] = Units(input=input, output=output)
+        return None

payi/lib/VertexInstrumentor.py

@@ -96,7 +96,7 @@ class _GoogleVertexRequest(_ProviderRequest):
             streaming_type=_StreamingType.generator,
             )
         self._prompt_character_count = 0
-        self._candiates_character_count = 0
+        self._candidates_character_count = 0
         self._model_name: Optional[str] = None
 
     @override
@@ -227,19 +227,21 @@ class _GoogleVertexRequest(_ProviderRequest):
         for candidate in response_dict.get("candidates", []):
             parts = candidate.get("content", {}).get("parts", [])
             for part in parts:
-                self._candiates_character_count += count_chars_skip_spaces(part.get("text", ""))
+                self._candidates_character_count += count_chars_skip_spaces(part.get("text", ""))
 
         usage = response_dict.get("usage_metadata", {})
         if usage and "prompt_token_count" in usage and "candidates_token_count" in usage:
-            self._compute_usage(response_dict, streaming_candidates_characters=self._candiates_character_count)
+            vertex_compute_usage(
+                request=self,
+                model=self._get_model_name(response_dict),
+                response_dict=response_dict,
+                prompt_character_count=self._prompt_character_count,
+                streaming_candidates_characters=self._candidates_character_count,
+            )
             ingest = True
 
         return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
     
-    @staticmethod
-    def _is_character_billing_model(model: str) -> bool:
-        return model.startswith("gemini-1.")
-    
     @override
     def process_synchronous_response(
         self,
@@ -256,108 +258,139 @@ class _GoogleVertexRequest(_ProviderRequest):
         if model:
             self._ingest["resource"] = "google." + model
 
-        self._compute_usage(response_dict)
+        vertex_compute_usage(
+            request=self,
+            model=model,
+            response_dict=response_dict,
+            prompt_character_count=self._prompt_character_count,
+            streaming_candidates_characters=self._candidates_character_count
+            )
         
         if log_prompt_and_response:
             self._ingest["provider_response_json"] = [json.dumps(response_dict)]
 
         return None
 
-    def add_units(self, key: str, input: Optional[int] = None, output: Optional[int] = None) -> None:
-        if key not in self._ingest["units"]:
-            self._ingest["units"][key] = {}
+def vertex_compute_usage(
+    request: _ProviderRequest,
+    model: Optional[str],
+    response_dict: 'dict[str, Any]',
+    prompt_character_count: int = 0,
+    streaming_candidates_characters: Optional[int] = None) -> None:
+
+    def is_character_billing_model(model: str) -> bool:
+        return model.startswith("gemini-1.")
+
+    def is_large_context_token_model(model: str, input_tokens: int) -> bool:
+        return model.startswith("gemini-2.5-pro") and input_tokens > 200_000
+
+    def add_units(request: _ProviderRequest, key: str, input: Optional[int] = None, output: Optional[int] = None) -> None:
+        if key not in request._ingest["units"]:
+            request._ingest["units"][key] = {}
         if input is not None:
-            self._ingest["units"][key]["input"] = input
+            request._ingest["units"][key]["input"] = input
         if output is not None:
-            self._ingest["units"][key]["output"] = output
-
-    def _compute_usage(self, response_dict: 'dict[str, Any]', streaming_candidates_characters: Optional[int] = None) -> None:
-        usage = response_dict.get("usage_metadata", {})
-        input = usage.get("prompt_token_count", 0)
+            request._ingest["units"][key]["output"] = output
 
-        prompt_tokens_details: list[dict[str, Any]] = usage.get("prompt_tokens_details", [])
-        candidates_tokens_details: list[dict[str, Any]] = usage.get("candidates_tokens_details", [])
+    usage = response_dict.get("usage_metadata", {})
+    input = usage.get("prompt_token_count", 0)
 
-        model: Optional[str] = self._get_model_name(response_dict)
-        if not model:
-            model = ""
-        
-        # for character billing only
-        large_context = "" if input < 128000 else "_large_context"
-
-        if self._is_character_billing_model(model):
-            # gemini 1.0 and 1.5 units are reported in characters, per second, per image, etc...
-            for details in prompt_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality == "TEXT":
-                    input = self._prompt_character_count
-                    if input == 0:
-                        # back up calc if nothing was calculated from the prompt
-                        input = response_dict["usage_metadata"]["prompt_token_count"] * 4
-
-                    output = 0
-                    if streaming_candidates_characters is None:
-                        for candidate in response_dict.get("candidates", []):
-                            parts = candidate.get("content", {}).get("parts", [])
-                            for part in parts:
-                                output += count_chars_skip_spaces(part.get("text", ""))
-
-                        if output == 0:
-                            # back up calc if no parts
-                            output = response_dict["usage_metadata"]["candidates_token_count"] * 4
-                    else:
-                        output = streaming_candidates_characters
-
-                    self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
-
-                elif modality == "IMAGE":
-                    num_images = math.ceil(modality_token_count / 258)
-                    self.add_units("vision"+large_context, input=num_images)
-
-                elif modality == "VIDEO":
-                    video_seconds = math.ceil(modality_token_count / 285)
-                    self.add_units("video"+large_context, input=video_seconds)
-
-                elif modality == "AUDIO":
-                    audio_seconds = math.ceil(modality_token_count / 25)
-                    self.add_units("audio"+large_context, input=audio_seconds)
+    prompt_tokens_details: list[dict[str, Any]] = usage.get("prompt_tokens_details", [])
+    candidates_tokens_details: list[dict[str, Any]] = usage.get("candidates_tokens_details", [])
 
-        else:
-            for details in prompt_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality == "IMAGE":
-                    self.add_units("vision", input=modality_token_count)
-                elif modality in ("VIDEO", "AUDIO", "TEXT"):
-                    self.add_units(modality.lower(), input=modality_token_count)
-            for details in candidates_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality in ("VIDEO", "AUDIO", "TEXT", "IMAGE"):
-                    self.add_units(modality.lower(), output=modality_token_count)
-
-        if not self._ingest["units"]:
-            input = usage.get("prompt_token_count", 0)
-            output = usage.get("candidates_token_count", 0) * 4
-            
-            if self._is_character_billing_model(model):
-                if self._prompt_character_count > 0:
-                    input = self._prompt_character_count
+    if not model:
+        model = ""
+    
+    large_context = ""
+
+    if is_character_billing_model(model):
+        if input > 128000: 
+            large_context = "_large_context"
+
+        # gemini 1.0 and 1.5 units are reported in characters, per second, per image, etc...
+        for details in prompt_tokens_details:
+            modality = details.get("modality", "")
+            if not modality:
+                continue
+
+            modality_token_count = details.get("token_count", 0)
+            if modality == "TEXT":
+                input = prompt_character_count
+                if input == 0:
+                    # back up calc if nothing was calculated from the prompt
+                    input = response_dict["usage_metadata"]["prompt_token_count"] * 4
+
+                output = 0
+                if streaming_candidates_characters is None:
+                    for candidate in response_dict.get("candidates", []):
+                        parts = candidate.get("content", {}).get("parts", [])
+                        for part in parts:
+                            output += count_chars_skip_spaces(part.get("text", ""))
+
+                    if output == 0:
+                        # back up calc if no parts
+                        output = response_dict["usage_metadata"]["candidates_token_count"] * 4
                 else:
-                    input *= 4
+                    output = streaming_candidates_characters
 
-                # if no units were added, add a default unit and assume 4 characters per token
-                self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
+                request._ingest["units"]["text"+large_context] = Units(input=input, output=output)
+
+            elif modality == "IMAGE":
+                num_images = math.ceil(modality_token_count / 258)
+                add_units(request, "vision"+large_context, input=num_images)
+
+            elif modality == "VIDEO":
+                video_seconds = math.ceil(modality_token_count / 285)
+                add_units(request, "video"+large_context, input=video_seconds)
+
+            elif modality == "AUDIO":
+                audio_seconds = math.ceil(modality_token_count / 25)
+                add_units(request, "audio"+large_context, input=audio_seconds)
+
+        # No need to gover the candidates_tokens_details as all the character based 1.x models only output TEXT
+        # for details in candidates_tokens_details:
+
+    else:
+        # thinking tokens introduced in 2.5 after the transition to token based billing
+        thinking_token_count = usage.get("thoughts_token_count", 0)
+
+        if is_large_context_token_model(model, input):
+            large_context = "_large_context"
+
+        for details in prompt_tokens_details:
+            modality = details.get("modality", "")
+            if not modality:
+                continue
+
+            modality_token_count = details.get("token_count", 0)
+            if modality == "IMAGE":
+                add_units(request, "vision"+large_context, input=modality_token_count)
+            elif modality in ("VIDEO", "AUDIO", "TEXT"):
+                add_units(request, modality.lower()+large_context, input=modality_token_count)
+        for details in candidates_tokens_details:
+            modality = details.get("modality", "")
+            if not modality:
+                continue
+
+            modality_token_count = details.get("token_count", 0)
+            if modality in ("VIDEO", "AUDIO", "TEXT", "IMAGE"):
+                add_units(request, modality.lower()+large_context, output=modality_token_count)
+
+        if thinking_token_count > 0:
+            add_units(request, "reasoning"+large_context, output=thinking_token_count)
+
+    if not request._ingest["units"]:
+        input = usage.get("prompt_token_count", 0)
+        output = usage.get("candidates_token_count", 0) * 4
+        
+        if is_character_billing_model(model):
+            if prompt_character_count > 0:
+                input = prompt_character_count
             else:
-                # if no units were added, add a default unit
-                self._ingest["units"]["text"] = Units(input=input, output=output)
+                input *= 4
+
+            # if no units were added, add a default unit and assume 4 characters per token
+            request._ingest["units"]["text"+large_context] = Units(input=input, output=output)
+        else:
+            # if no units were added, add a default unit
+            request._ingest["units"]["text"] = Units(input=input, output=output)

payi/lib/instrument.py

@@ -55,9 +55,14 @@ class _ProviderRequest:
     def process_request_prompt(self, prompt: 'dict[str, Any]', args: Sequence[Any], kwargs: 'dict[str, Any]') -> None:
         ...
     
+    def process_initial_stream_response(self, response: Any) -> None:
+        pass
+
+    @property
     def is_bedrock(self) -> bool:
         return self._category == PayiCategories.aws_bedrock
 
+    @property
     def is_vertex(self) -> bool:
         return self._category == PayiCategories.google_vertex 
        
@@ -65,6 +70,10 @@ class _ProviderRequest:
         self.exception_to_semantic_failure(exception)
         return True
     
+    @property
+    def supports_extra_headers(self) -> bool:
+        return not self.is_bedrock and not self.is_vertex
+    
     @property
     def streaming_type(self) -> '_StreamingType':
         return self._streaming_type
@@ -806,8 +815,7 @@ class _PayiInstrumentor:
         context = self.get_context()
 
         if not context:
-            if request.is_bedrock():
-                # boto3 doesn't allow extra_headers
+            if not request.supports_extra_headers:
                 kwargs.pop("extra_headers", None)
 
             self._logger.debug(f"invoke_wrapper: no instrumentation context, exit early")
@@ -822,8 +830,7 @@ class _PayiInstrumentor:
         self._update_extra_headers(context, extra_headers)
 
         if context.get("proxy", self._proxy_default):
-            if request.is_bedrock():
-                # boto3 doesn't allow extra_headers
+            if not request.supports_extra_headers:
                 kwargs.pop("extra_headers", None)
             elif "extra_headers" not in kwargs and extra_headers:
                 # assumes anthropic and openai clients
@@ -899,7 +906,7 @@ class _PayiInstrumentor:
                     request=request,
                 )
 
-                if request.is_bedrock():
+                if request.is_bedrock:
                     if "body" in response:
                         response["body"] = stream_result
                     else:
@@ -1084,9 +1091,10 @@ class _StreamIteratorWrapper(ObjectProxy):  # type: ignore
 
         instrumentor._logger.debug(f"StreamIteratorWrapper: instance {instance}, category {request._category}")
 
+        request.process_initial_stream_response(response)
+
         bedrock_from_stream: bool = False
-        if request.is_bedrock():
-            request._ingest["provider_response_id"] = response["ResponseMetadata"]["RequestId"]
+        if request.is_bedrock:
             stream = response.get("stream", None)
 
             if stream:
@@ -1108,7 +1116,6 @@ class _StreamIteratorWrapper(ObjectProxy):  # type: ignore
         self._request: _ProviderRequest = request
 
         self._first_token: bool = True
-        self._is_bedrock: bool = request.is_bedrock()
         self._bedrock_from_stream: bool = bedrock_from_stream
         self._ingested: bool = False
         self._iter_started: bool = False
@@ -1131,7 +1138,7 @@ class _StreamIteratorWrapper(ObjectProxy):  # type: ignore
 
     def __iter__(self) -> Any:  
         self._iter_started = True
-        if self._is_bedrock:
+        if self._request.is_bedrock:
             # MUST reside in a separate function so that the yield statement (e.g. the generator) doesn't implicitly return its own iterator and overriding self
             self._instrumentor._logger.debug(f"StreamIteratorWrapper: bedrock __iter__")
             return self._iter_bedrock()

payi/resources/categories/__init__.py

@@ -16,6 +16,14 @@ from .categories import (
     CategoriesResourceWithStreamingResponse,
     AsyncCategoriesResourceWithStreamingResponse,
 )
+from .fixed_cost_resources import (
+    FixedCostResourcesResource,
+    AsyncFixedCostResourcesResource,
+    FixedCostResourcesResourceWithRawResponse,
+    AsyncFixedCostResourcesResourceWithRawResponse,
+    FixedCostResourcesResourceWithStreamingResponse,
+    AsyncFixedCostResourcesResourceWithStreamingResponse,
+)
 
 __all__ = [
     "ResourcesResource",
@@ -24,6 +32,12 @@ __all__ = [
     "AsyncResourcesResourceWithRawResponse",
     "ResourcesResourceWithStreamingResponse",
     "AsyncResourcesResourceWithStreamingResponse",
+    "FixedCostResourcesResource",
+    "AsyncFixedCostResourcesResource",
+    "FixedCostResourcesResourceWithRawResponse",
+    "AsyncFixedCostResourcesResourceWithRawResponse",
+    "FixedCostResourcesResourceWithStreamingResponse",
+    "AsyncFixedCostResourcesResourceWithStreamingResponse",
     "CategoriesResource",
     "AsyncCategoriesResource",
     "CategoriesResourceWithRawResponse",

payi/resources/categories/categories.py

@@ -25,6 +25,14 @@ from ..._response import (
 )
 from ...pagination import SyncCursorPage, AsyncCursorPage
 from ..._base_client import AsyncPaginator, make_request_options
+from .fixed_cost_resources import (
+    FixedCostResourcesResource,
+    AsyncFixedCostResourcesResource,
+    FixedCostResourcesResourceWithRawResponse,
+    AsyncFixedCostResourcesResourceWithRawResponse,
+    FixedCostResourcesResourceWithStreamingResponse,
+    AsyncFixedCostResourcesResourceWithStreamingResponse,
+)
 from ...types.category_response import CategoryResponse
 from ...types.category_delete_response import CategoryDeleteResponse
 from ...types.category_resource_response import CategoryResourceResponse
@@ -38,6 +46,10 @@ class CategoriesResource(SyncAPIResource):
     def resources(self) -> ResourcesResource:
         return ResourcesResource(self._client)
 
+    @cached_property
+    def fixed_cost_resources(self) -> FixedCostResourcesResource:
+        return FixedCostResourcesResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> CategoriesResourceWithRawResponse:
         """
@@ -225,6 +237,10 @@ class AsyncCategoriesResource(AsyncAPIResource):
     def resources(self) -> AsyncResourcesResource:
         return AsyncResourcesResource(self._client)
 
+    @cached_property
+    def fixed_cost_resources(self) -> AsyncFixedCostResourcesResource:
+        return AsyncFixedCostResourcesResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncCategoriesResourceWithRawResponse:
         """
@@ -428,6 +444,10 @@ class CategoriesResourceWithRawResponse:
     def resources(self) -> ResourcesResourceWithRawResponse:
         return ResourcesResourceWithRawResponse(self._categories.resources)
 
+    @cached_property
+    def fixed_cost_resources(self) -> FixedCostResourcesResourceWithRawResponse:
+        return FixedCostResourcesResourceWithRawResponse(self._categories.fixed_cost_resources)
+
 
 class AsyncCategoriesResourceWithRawResponse:
     def __init__(self, categories: AsyncCategoriesResource) -> None:
@@ -450,6 +470,10 @@ class AsyncCategoriesResourceWithRawResponse:
     def resources(self) -> AsyncResourcesResourceWithRawResponse:
         return AsyncResourcesResourceWithRawResponse(self._categories.resources)
 
+    @cached_property
+    def fixed_cost_resources(self) -> AsyncFixedCostResourcesResourceWithRawResponse:
+        return AsyncFixedCostResourcesResourceWithRawResponse(self._categories.fixed_cost_resources)
+
 
 class CategoriesResourceWithStreamingResponse:
     def __init__(self, categories: CategoriesResource) -> None:
@@ -472,6 +496,10 @@ class CategoriesResourceWithStreamingResponse:
     def resources(self) -> ResourcesResourceWithStreamingResponse:
         return ResourcesResourceWithStreamingResponse(self._categories.resources)
 
+    @cached_property
+    def fixed_cost_resources(self) -> FixedCostResourcesResourceWithStreamingResponse:
+        return FixedCostResourcesResourceWithStreamingResponse(self._categories.fixed_cost_resources)
+
 
 class AsyncCategoriesResourceWithStreamingResponse:
     def __init__(self, categories: AsyncCategoriesResource) -> None:
@@ -493,3 +521,7 @@ class AsyncCategoriesResourceWithStreamingResponse:
     @cached_property
     def resources(self) -> AsyncResourcesResourceWithStreamingResponse:
         return AsyncResourcesResourceWithStreamingResponse(self._categories.resources)
+
+    @cached_property
+    def fixed_cost_resources(self) -> AsyncFixedCostResourcesResourceWithStreamingResponse:
+        return AsyncFixedCostResourcesResourceWithStreamingResponse(self._categories.fixed_cost_resources)