monocle-apptrace 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/gemini/entities/retrieval.py

@@ -0,0 +1,43 @@
+from monocle_apptrace.instrumentation.metamodel.gemini import (
+    _helper,
+)
+
+RETRIEVAL = {
+    "type": "retrieval",
+    "attributes": [
+        [
+            {
+                "_comment": "Embedding Model",
+                "attribute": "name",
+                "accessor": lambda arguments: _helper.resolve_from_alias(arguments['kwargs'],
+                                                                         ['model'])
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'model.embedding.' + _helper.resolve_from_alias(arguments['kwargs'],
+                                                                                        ['model'])
+            }
+        ]
+    ],
+    "events": [
+        {
+         "name": "data.input",
+         "attributes": [
+             {
+                 "attribute": "input",
+                 "accessor": lambda arguments: _helper.update_input_span_events(arguments['kwargs'])
+             }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.update_output_span_events(arguments['result'])
+                }
+            ]
+        }
+
+    ]
+}

monocle_apptrace/instrumentation/metamodel/gemini/methods.py

@@ -1,7 +1,10 @@
-from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
 from monocle_apptrace.instrumentation.metamodel.gemini.entities.inference import (
     INFERENCE,
 )
+from monocle_apptrace.instrumentation.metamodel.gemini.entities.retrieval import (
+    RETRIEVAL,
+)
 
 GEMINI_METHODS = [
     {
@@ -10,5 +13,19 @@ GEMINI_METHODS = [
       "method": "generate_content",
       "wrapper_method": task_wrapper,
       "output_processor": INFERENCE,
+    },
+    {
+      "package": "google.genai.models",
+      "object": "AsyncModels",
+      "method": "generate_content",
+      "wrapper_method": atask_wrapper,
+      "output_processor": INFERENCE,
+    },
+    {
+      "package": "google.genai.models",
+      "object": "Models",
+      "method": "embed_content",
+      "wrapper_method": task_wrapper,
+      "output_processor": RETRIEVAL,
     }
 ]

monocle_apptrace/instrumentation/metamodel/haystack/_helper.py

@@ -2,12 +2,15 @@ import logging
 
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
+    get_json_dumps,
     get_keys_as_tuple,
     get_nested_value,
     try_option,
     get_exception_message,
     get_status_code,
 )
+from monocle_apptrace.instrumentation.metamodel.finish_types import map_haystack_finish_reason_to_finish_type
+
 logger = logging.getLogger(__name__)
 
 
@@ -56,24 +59,27 @@ def extract_question_from_prompt(content):
 
 def extract_assistant_message(arguments):
     status = get_status_code(arguments)
-    response: str = ""
+    messages = []
+    role = "assistant"
     if status == 'success':
+        response = ""
         if "replies" in arguments['result']:
             reply = arguments['result']["replies"][0]
+            if hasattr(reply, role) and hasattr(reply,role, "value") and isinstance(reply.role.value, str):
+                role = reply.role.value or role
             if hasattr(reply, 'content'):
                 response = reply.content
             elif hasattr(reply, 'text'):
                 response = reply.text
             else:
                 response = reply
+        messages.append({role: response})
     else:
         if arguments["exception"] is not None:
-            response = get_exception_message(arguments)
-        elif hasattr(response, "error"):
-            response = arguments['result'].error
-
-    return response
-
+            return get_exception_message(arguments)
+        elif hasattr(arguments["result"], "error"):
+            return arguments['result'].error
+    return get_json_dumps(messages[0]) if messages else ""
 
 def get_vectorstore_deployment(my_map):
     if isinstance(my_map, dict):
@@ -112,7 +118,10 @@ def resolve_from_alias(my_map, alias):
     return None
 
 def extract_inference_endpoint(instance):
-    inference_endpoint: Option[str] = try_option(getattr, instance.client, 'base_url').map(str)
+    if hasattr(instance, '_model_name') and isinstance(instance._model_name, str) and 'gemini' in instance._model_name.lower():
+        inference_endpoint = try_option(lambda: f"https://generativelanguage.googleapis.com/v1beta/models/{instance._model_name}:generateContent")
+    if hasattr(instance, 'client') and hasattr(instance.client, 'base_url'):
+        inference_endpoint: Option[str] = try_option(getattr, instance.client, 'base_url').map(str)
     if inference_endpoint.is_none():
         inference_endpoint = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
 
@@ -146,3 +155,65 @@ def update_output_span_events(results):
     if len(output_arg_text) > 100:
         output_arg_text = output_arg_text[:100] + "..."
     return output_arg_text
+
+def extract_finish_reason(arguments):
+    """Extract finish_reason from Haystack response."""
+    try:
+        # Handle exception cases first
+        if arguments.get("exception") is not None:
+            return "error"
+
+        response = arguments.get("result")
+        if response is None:
+            return None
+
+        # Direct finish_reason attribute
+        if hasattr(response, "finish_reason") and response.finish_reason:
+            return response.finish_reason
+
+        if isinstance(response,dict) and 'meta' in response and response['meta'] and len(response['meta']) > 0:
+            metadata = response['meta'][0]
+            if isinstance(metadata, dict):
+                # Check for finish_reason in metadata
+                if "finish_reason" in metadata:
+                    return metadata["finish_reason"]
+
+        if isinstance(response,dict) and 'replies' in response and response['replies'] and len(response['replies']) > 0:
+            metadata = response['replies'][0]
+            if hasattr(metadata,'meta') and metadata.meta:
+                if "finish_reason" in metadata.meta:
+                    return metadata.meta["finish_reason"]
+
+        # Check if response has generation_info
+        if hasattr(response, "generation_info") and response.generation_info:
+            finish_reason = response.generation_info.get("finish_reason")
+            if finish_reason:
+                return finish_reason
+
+        # Check if response has llm_output (batch responses)
+        if hasattr(response, "llm_output") and response.llm_output:
+            finish_reason = response.llm_output.get("finish_reason")
+            if finish_reason:
+                return finish_reason
+
+        # For AIMessage responses, check additional_kwargs
+        if hasattr(response, "additional_kwargs") and response.additional_kwargs:
+            finish_reason = response.additional_kwargs.get("finish_reason")
+            if finish_reason:
+                return finish_reason
+
+        # For generation responses with choices (similar to OpenAI structure)
+        if hasattr(response, "choices") and response.choices:
+            choice = response.choices[0]
+            if hasattr(choice, "finish_reason"):
+                return choice.finish_reason
+
+        # Fallback: if no finish_reason found, default to "stop" (success)
+        return "stop"
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_finish_reason: %s", str(e))
+        return None
+
+def map_finish_reason_to_finish_type(finish_reason):
+    """Map Haystack finish_reason to finish_type using Haystack mapping."""
+    return map_haystack_finish_reason_to_finish_type(finish_reason)

monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py

@@ -1,7 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.haystack import (
     _helper,
 )
-from monocle_apptrace.instrumentation.common.utils import get_llm_type, get_status, get_status_code
+from monocle_apptrace.instrumentation.common.utils import get_error_message, get_llm_type
 
 INFERENCE = {
     "type": "inference.framework",
@@ -35,12 +35,12 @@ INFERENCE = {
                 "_comment": "LLM Model",
                 "attribute": "name",
                 "accessor": lambda arguments: _helper.resolve_from_alias(arguments['instance'].__dict__,
-                                                                         ['model', 'model_name'])
+                                                                         ['model', 'model_name','_model_name'])
             },
             {
                 "attribute": "type",
                 "accessor": lambda arguments: 'model.llm.' + _helper.resolve_from_alias(arguments['instance'].__dict__,
-                                                                                        ['model', 'model_name'])
+                                                                                        ['model', 'model_name','_model_name'])
             }
         ]
     ],
@@ -59,13 +59,8 @@ INFERENCE = {
             "name": "data.output",
             "attributes": [
                 {
-                    "_comment": "this is response from LLM",
-                    "attribute": "status",
-                    "accessor": lambda arguments: get_status(arguments)
-                },
-                {
-                    "attribute": "status_code",
-                    "accessor": lambda arguments: get_status_code(arguments)
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
                 },
                 {
                     "attribute": "response",
@@ -80,6 +75,16 @@ INFERENCE = {
                     "_comment": "this is metadata usage from LLM",
                     "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'],
                                                                                         arguments['instance'])
+                },
+                {
+                    "attribute": "finish_reason",
+                    "accessor": lambda arguments: _helper.extract_finish_reason(arguments)
+                },
+                {
+                    "attribute": "finish_type",
+                    "accessor": lambda arguments: _helper.map_finish_reason_to_finish_type(
+                        _helper.extract_finish_reason(arguments)
+                    )
                 }
             ]
         }

monocle_apptrace/instrumentation/metamodel/haystack/methods.py

@@ -44,4 +44,11 @@ HAYSTACK_METHODS = [
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
+    {
+        "package": "haystack_integrations.components.generators.google_ai",
+        "object": "GoogleAIGeminiChatGenerator",
+        "method": "run",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    },
 ]

monocle_apptrace/instrumentation/metamodel/lambdafunc/_helper.py

@@ -0,0 +1,78 @@
+import logging
+from threading import local
+from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, try_option, Option, \
+    MonocleSpanException
+from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+from monocle_apptrace.instrumentation.common.constants import HTTP_SUCCESS_CODES
+from urllib.parse import unquote, urlparse, ParseResult
+
+logger = logging.getLogger(__name__)
+MAX_DATA_LENGTH = 1000
+token_data = local()
+token_data.current_token = None
+
+def get_url(kwargs) -> ParseResult:
+    url_str = try_option(lambda k: k.get('path'), kwargs['event'])
+    url = url_str.unwrap_or(None)
+    if url is not None:
+        return urlparse(url)
+    else:
+        return None
+
+def get_route(args) -> str:
+    event = args[1]
+    route = event.get("path") or event.get("requestContext", {}).get("path")
+    return route
+
+def get_method(args) -> str:
+    event = args[1]
+    http_method = event.get("httpMethod") or event.get("requestContext", {}).get("httpMethod")
+    return http_method
+
+
+def get_params(args) -> dict:
+    event = args[1]
+    question = None
+    query_params = event.get('queryStringParameters', {})
+    if isinstance(query_params, dict):
+        question = query_params.get('question')
+    return question
+
+def get_body(args) -> dict:
+    event = args[1]
+    body = event.get("body")
+    return body
+
+def extract_response(result) -> str:
+    if isinstance(result, dict) and 'body' in result:
+        response = result['body']
+        if isinstance(response, bytes):
+            response = response.decode('utf-8', errors='ignore')
+    else:
+        response = ""
+    return response
+
+
+def extract_status(result) -> str:
+    status = f"{result['statusCode']}" if isinstance(result, dict) and 'statusCode' in result else ""
+    if status not in HTTP_SUCCESS_CODES:
+        error_message = extract_response(result)
+        raise MonocleSpanException(f"error: {status} - {error_message}")
+    return status
+
+
+def lambda_func_pre_tracing(kwargs):
+    headers = kwargs['event'].get('headers', {}) if 'event' in kwargs else {}
+    return extract_http_headers(headers)
+
+
+def lambda_func_post_tracing(token):
+    clear_http_scopes(token)
+
+
+class lambdaSpanHandler(SpanHandler):
+    def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
+        return lambda_func_pre_tracing(kwargs)
+
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value,token):
+        lambda_func_post_tracing(token)

monocle_apptrace/instrumentation/metamodel/lambdafunc/entities/http.py

@@ -0,0 +1,51 @@
+from monocle_apptrace.instrumentation.metamodel.lambdafunc import _helper
+LAMBDA_HTTP_PROCESSOR = {
+    "type": "http.process",
+    "attributes": [
+        [
+            {
+                "_comment": "request method, request URI",
+                "attribute": "method",
+                "accessor": lambda arguments: _helper.get_method(arguments['args'])
+            },
+            {
+                "_comment": "request method, request URI",
+                "attribute": "route",
+                "accessor": lambda arguments: _helper.get_route(arguments['args'])
+            },
+            {
+                "_comment": "request method, request URI",
+                "attribute": "body",
+                "accessor": lambda arguments: _helper.get_body(arguments['args'])
+            },
+        ]
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "route params",
+                    "attribute": "params",
+                    "accessor": lambda arguments: _helper.get_params(arguments['args'])
+                }
+            ]
+        },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "status from HTTP response",
+                    "attribute": "status",
+                    "accessor": lambda arguments: _helper.extract_status(arguments['result'])
+                },
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_response(arguments['result'])
+                }
+            ]
+        }
+
+    ]
+}

monocle_apptrace/instrumentation/metamodel/lambdafunc/methods.py

@@ -0,0 +1,23 @@
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
+from monocle_apptrace.instrumentation.metamodel.lambdafunc.entities.http import LAMBDA_HTTP_PROCESSOR
+
+LAMBDA_HTTP_METHODS = [
+    {
+        "package": "monocle_apptrace.instrumentation.metamodel.lambdafunc.wrapper",
+        "object": "LambdaFunctionRouteWrapper",
+        "method": "run_async",
+        "span_name": "lambda_function_route",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "lambda_func_handler",
+        "output_processor": LAMBDA_HTTP_PROCESSOR
+    },
+    {
+        "package": "monocle_apptrace.instrumentation.metamodel.lambdafunc.wrapper",
+        "object": "LambdaFunctionRouteWrapper",
+        "method": "run_sync",
+        "span_name": "lambda_function_route",
+        "wrapper_method": task_wrapper,
+        "span_handler": "lambda_func_handler",
+        "output_processor": LAMBDA_HTTP_PROCESSOR
+    }
+]

monocle_apptrace/instrumentation/metamodel/lambdafunc/wrapper.py

@@ -0,0 +1,23 @@
+from functools import wraps
+import inspect
+
+def monocle_trace_lambda_function_route(func):
+    if inspect.iscoroutinefunction(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            return await LambdaFunctionRouteWrapper.run_async(func, *args, **kwargs)
+        return wrapper
+    else:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return LambdaFunctionRouteWrapper.run_sync(func, *args, **kwargs)
+        return wrapper
+
+class LambdaFunctionRouteWrapper:
+    @staticmethod
+    async def run_async(func, *args, **kwargs):
+        return await func(*args, **kwargs)
+
+    @staticmethod
+    def run_sync(func, *args, **kwargs):
+        return func(*args, **kwargs)

monocle_apptrace/instrumentation/metamodel/langchain/_helper.py

@@ -4,14 +4,18 @@ and assistant messages from various input formats.
 """
 
 import logging
+from opentelemetry.context import get_value
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, INFERENCE_AGENT_DELEGATION, INFERENCE_COMMUNICATION, INFERENCE_TOOL_CALL
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
+    get_json_dumps,
     get_keys_as_tuple,
     get_nested_value,
     try_option,
     get_exception_message,
     get_status_code,
 )
+from monocle_apptrace.instrumentation.metamodel.finish_types import map_langchain_finish_reason_to_finish_type
 
 
 logger = logging.getLogger(__name__)
@@ -32,45 +36,80 @@ def extract_messages(args):
                 for msg in args[0].messages:
                     if hasattr(msg, 'content') and hasattr(msg, 'type'):
                         messages.append({msg.type: msg.content})
-        return [str(d) for d in messages]
+            else:
+                for msg in args[0]:
+                    if hasattr(msg, 'content') and hasattr(msg, 'type') and msg.content:
+                        messages.append({msg.type: msg.content})
+                    elif hasattr(msg, 'tool_calls') and msg.tool_calls:
+                        messages.append({msg.type: get_json_dumps(msg.tool_calls)})
+        return [get_json_dumps(d) for d in messages]
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
         return []
+def agent_inference_type(arguments):
+    """Extract agent inference type from arguments."""
+    try:
+        if get_value(AGENT_PREFIX_KEY):
+            agent_prefix = get_value(AGENT_PREFIX_KEY)
+            if hasattr(arguments['result'], "tool_calls") and arguments['result'].tool_calls:
+                tool_call = arguments['result'].tool_calls[0] if arguments['result'].tool_calls else None
+                if tool_call and 'name' in tool_call and tool_call["name"].startswith(agent_prefix):
+                    return INFERENCE_AGENT_DELEGATION
+                else:
+                    return INFERENCE_TOOL_CALL
+        return INFERENCE_COMMUNICATION
+            
+    except Exception as e:
+        logger.warning("Warning: Error occurred in agent_inference_type: %s", str(e))
+        return None
 
 def extract_assistant_message(arguments):
     status = get_status_code(arguments)
-    response: str = ""
+    messages = []
+    role = "assistant"
     if status == 'success':
         if isinstance(arguments['result'], str):
-            response = arguments['result']
-        if hasattr(arguments['result'], "content"):
-            response = arguments['result'].content
-        if hasattr(arguments['result'], "message") and hasattr(arguments['result'].message, "content"):
-            response =  arguments['result'].message.content
+            messages.append({role: arguments['result']})
+        elif hasattr(arguments['result'], "content") and arguments['result'].content != "":
+            role = arguments['result'].type if hasattr(arguments['result'], 'type') else role
+            messages.append({role: arguments['result'].content})
+        elif hasattr(arguments['result'], "message") and hasattr(arguments['result'].message, "content") and arguments['result'].message.content != "":
+            role = arguments['result'].type if hasattr(arguments['result'], 'type') else role
+            messages.append({role: arguments['result'].message.content})
+        elif hasattr(arguments['result'], "tool_calls"):
+            role = arguments['result'].type if hasattr(arguments['result'], 'type') else role
+            messages.append({role: arguments['result'].tool_calls[0]})
     else:
         if arguments["exception"] is not None:
-            response = get_exception_message(arguments)
+            messages.append({role: get_exception_message(arguments)})
         elif hasattr(arguments["result"], "error"):
-            response = arguments["result"].error
-
-    return response
-
+            return arguments["result"].error
+    return get_json_dumps(messages[0]) if messages else ""
 
 def extract_provider_name(instance):
-    provider_url: Option[str] = None
-    if hasattr(instance,'client'):
+    provider_url: Option[str] = Option(None)
+    if hasattr(instance, 'client'):
+        provider_url: Option[str] = try_option(getattr, instance.client, 'universe_domain')
+    if hasattr(instance,'client') and hasattr(instance.client, '_client') and hasattr(instance.client._client, 'base_url'):
+        # If the client has a base_url, extract the host from it
         provider_url: Option[str] = try_option(getattr, instance.client._client.base_url, 'host')
-    if hasattr(instance, '_client'):
+    if hasattr(instance, '_client') and hasattr(instance._client, 'base_url'):
         provider_url = try_option(getattr, instance._client.base_url, 'host')
     return provider_url.unwrap_or(None)
 
 
 def extract_inference_endpoint(instance):
     inference_endpoint: Option[str] = None
-    if hasattr(instance,'client'):
+    # instance.client.meta.endpoint_url
+    if hasattr(instance, 'client') and hasattr(instance.client, 'transport'):
+        inference_endpoint: Option[str] = try_option(getattr, instance.client.transport, 'host')
+
+    if hasattr(instance, 'client') and hasattr(instance.client, 'meta') and hasattr(instance.client.meta, 'endpoint_url'):
+        inference_endpoint: Option[str] = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
+
+    if hasattr(instance,'client') and hasattr(instance.client, '_client'):
         inference_endpoint: Option[str] = try_option(getattr, instance.client._client, 'base_url').map(str)
-        if inference_endpoint.is_none() and "meta" in instance.client.__dict__:
-            inference_endpoint = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
+
     if hasattr(instance,'_client'):
         inference_endpoint = try_option(getattr, instance._client, 'base_url').map(str)
 
@@ -138,4 +177,91 @@ def update_span_from_llm_response(response, instance):
                 {"completion_tokens": token_usage.get("completion_tokens") or token_usage.get("output_tokens")})
             meta_dict.update({"prompt_tokens": token_usage.get("prompt_tokens") or token_usage.get("input_tokens")})
             meta_dict.update({"total_tokens": token_usage.get("total_tokens")})
-    return meta_dict
+    return meta_dict
+
+def extract_finish_reason(arguments):
+    """Extract finish_reason from LangChain response."""
+    try:
+        # Handle exception cases first
+        if arguments.get("exception") is not None:
+            # If there's an exception, it's typically an error finish type
+            return "error"
+        
+        response = arguments.get("result")
+        if response is None:
+            return None
+            
+        # Check various possible locations for finish_reason in LangChain responses
+        
+        # Direct finish_reason attribute
+        if hasattr(response, "finish_reason") and response.finish_reason:
+            return response.finish_reason
+            
+        # Response metadata (common in LangChain)
+        if hasattr(response, "response_metadata") and response.response_metadata:
+            metadata = response.response_metadata
+            if isinstance(metadata, dict):
+                # Check for finish_reason in metadata
+                if "finish_reason" in metadata:
+                    return metadata["finish_reason"]
+                # Check for stop_reason (Anthropic style through LangChain)
+                if "stop_reason" in metadata:
+                    return metadata["stop_reason"]
+                # Check for other common finish reason keys
+                for key in ["completion_reason", "end_reason", "status"]:
+                    if key in metadata:
+                        return metadata[key]
+        
+        # Check if response has generation_info (some LangChain models)
+        if hasattr(response, "generation_info") and response.generation_info:
+            gen_info = response.generation_info
+            if isinstance(gen_info, dict):
+                for key in ["finish_reason", "stop_reason", "completion_reason"]:
+                    if key in gen_info:
+                        return gen_info[key]
+        
+        # Check if response has llm_output (batch responses)
+        if hasattr(response, "llm_output") and response.llm_output:
+            llm_output = response.llm_output
+            if isinstance(llm_output, dict):
+                for key in ["finish_reason", "stop_reason"]:
+                    if key in llm_output:
+                        return llm_output[key]
+        
+        # For AIMessage responses, check additional_kwargs
+        if hasattr(response, "additional_kwargs") and response.additional_kwargs:
+            kwargs = response.additional_kwargs
+            if isinstance(kwargs, dict):
+                for key in ["finish_reason", "stop_reason"]:
+                    if key in kwargs:
+                        return kwargs[key]
+        
+        # For generation responses with choices (similar to OpenAI structure)
+        if hasattr(response, "generations") and response.generations:
+            generations = response.generations
+            if isinstance(generations, list) and len(generations) > 0:
+                for generation in generations:
+                    if hasattr(generation, "generation_info") and generation.generation_info:
+                        gen_info = generation.generation_info
+                        if isinstance(gen_info, dict):
+                            for key in ["finish_reason", "stop_reason"]:
+                                if key in gen_info:
+                                    return gen_info[key]
+        
+        # If no specific finish reason found, infer from status
+        status_code = get_status_code(arguments)
+        if status_code == 'success':
+            return "stop"  # Default success finish reason
+        elif status_code == 'error':
+            return "error"
+            
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_finish_reason: %s", str(e))
+        return None
+    
+    return None
+
+
+def map_finish_reason_to_finish_type(finish_reason):
+    """Map LangChain finish_reason to finish_type."""
+    return map_langchain_finish_reason_to_finish_type(finish_reason)