monocle-apptrace 0.3.1b1__py3-none-any.whl → 0.4.0b1__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/aiohttp/_helper.py

@@ -0,0 +1,66 @@
+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
+
+logger = logging.getLogger(__name__)
+MAX_DATA_LENGTH = 1000
+token_data = local()
+token_data.current_token = None
+
+def get_route(args) -> str:
+    route_path: Option[str] = try_option(getattr, args[0], 'path')
+    return route_path.unwrap_or("")
+
+def get_method(args) -> str:
+#    return args[0]['method'] if 'method' in args[0] else ""
+    http_method: Option[str] = try_option(getattr, args[0], 'method')
+    return http_method.unwrap_or("")
+
+def get_params(args) -> dict:
+    params: Option[str] = try_option(getattr, args[0], 'query_string')
+    return unquote(params.unwrap_or(""))
+
+def get_body(args) -> dict:
+    return ""
+
+def extract_response(result) -> str:
+    if hasattr(result, 'text'):
+        response = result.text[0:max(result.text.__len__(), MAX_DATA_LENGTH)]
+    else:
+        response = ""
+    return response
+
+def extract_status(result) -> str:
+    status = f"{result.status}" if hasattr(result, 'status') else ""
+    if status not in HTTP_SUCCESS_CODES:
+        error_message = extract_response(result)
+        raise MonocleSpanException(f"error: {status} - {error_message}")
+    return status
+
+def aiohttp_pre_tracing(args):
+    token_data.current_token = extract_http_headers(args[0].headers)
+
+def aiohttp_post_tracing():
+    clear_http_scopes(token_data.current_token)
+    token_data.current_token = None
+
+def aiohttp_skip_span(args) -> bool:
+    if get_method(args) == "HEAD":
+        return True
+    return False
+
+class aiohttpSpanHandler(SpanHandler):
+
+    def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
+        aiohttp_pre_tracing(args)
+        return super().pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+    
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+        aiohttp_post_tracing()
+        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+
+    def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
+        return aiohttp_skip_span(args)

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

@@ -0,0 +1,51 @@
+from monocle_apptrace.instrumentation.metamodel.aiohttp import _helper
+AIO_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/aiohttp/methods.py

@@ -0,0 +1,13 @@
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper
+from monocle_apptrace.instrumentation.metamodel.aiohttp.entities.http import AIO_HTTP_PROCESSOR
+
+AIOHTTP_METHODS = [
+    {
+        "package": "aiohttp.web_app",
+        "object": "Application",
+        "method": "_handle",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "aiohttp_handler",
+        "output_processor": AIO_HTTP_PROCESSOR
+    }
+]

monocle_apptrace/instrumentation/metamodel/anthropic/methods.py

@@ -5,17 +5,19 @@ from monocle_apptrace.instrumentation.metamodel.anthropic.entities.inference imp
 
 ANTHROPIC_METHODS = [
     {
-        "package": "anthropic.resources.messages.messages",
+        "package": "anthropic.resources",
         "object": "Messages",
         "method": "create",
         "wrapper_method": task_wrapper,
+        "span_handler": "non_framework_handler",
         "output_processor": INFERENCE
     },
     {
-        "package": "anthropic.resources.messages.messages",
+        "package": "anthropic.resources",
         "object": "AsyncMessages",
         "method": "create",
         "wrapper_method": atask_wrapper,
+        "span_handler": "non_framework_handler",
         "output_processor": INFERENCE
     },
 

monocle_apptrace/instrumentation/metamodel/flask/_helper.py

@@ -1,11 +1,46 @@
+import logging
 from threading import local
 from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes
-from opentelemetry.propagate import extract
-from opentelemetry.context import Context, attach, detach
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+from monocle_apptrace.instrumentation.common.constants import HTTP_SUCCESS_CODES
+from monocle_apptrace.instrumentation.common.utils import MonocleSpanException
+from urllib.parse import unquote
+from opentelemetry.context import get_current
+from opentelemetry.trace import Span, get_current_span
+from opentelemetry.trace.propagation import _SPAN_KEY
+
+logger = logging.getLogger(__name__)
+MAX_DATA_LENGTH = 1000
 token_data = local()
 token_data.current_token = None
 
+def get_route(args) -> str:
+    return args[0]['PATH_INFO'] if 'PATH_INFO' in args[0] else ""
+
+def get_method(args) -> str:
+    return args[0]['REQUEST_METHOD'] if 'REQUEST_METHOD' in args[0] else ""
+
+def get_params(args) -> dict:
+    params = args[0]['QUERY_STRING'] if 'QUERY_STRING' in args[0] else ""
+    return unquote(params)
+
+def get_body(args) -> dict:
+    return ""
+
+def extract_response(instance) -> str:
+    if hasattr(instance, 'data') and hasattr(instance, 'content_length'):
+        response = instance.data[0:max(instance.content_length, MAX_DATA_LENGTH)]
+    else:
+        response = ""
+    return response
+
+def extract_status(instance) -> str:
+    status = f"{instance.status_code}" if hasattr(instance, 'status_code') else ""
+    if status not in HTTP_SUCCESS_CODES:
+        error_message = extract_response(instance)
+        raise MonocleSpanException(f"error: {status} - {error_message}")
+    return status
+
 def flask_pre_tracing(args):
     headers = dict()
     for key, value in args[0].items():
@@ -26,4 +61,16 @@ class FlaskSpanHandler(SpanHandler):
     
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
         flask_post_tracing()
-        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+
+class FlaskResponseSpanHandler(SpanHandler):
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+        try:
+            _parent_span_context = get_current()
+            if _parent_span_context is not None:
+                parent_span: Span = _parent_span_context.get(_SPAN_KEY, None)
+                if parent_span is not None:
+                    self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, return_value, parent_span)
+        except Exception as e:
+            logger.info(f"Failed to propogate flask response: {e}")
+        super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)

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

@@ -0,0 +1,48 @@
+from monocle_apptrace.instrumentation.metamodel.flask import _helper
+FLASK_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'])
+            },
+        ]
+    ]
+}
+
+FLASK_RESPONSE_PROCESSOR = {
+    "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['instance'])
+                },
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_response(arguments['instance'])
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/flask/methods.py

@@ -1,13 +1,22 @@
 from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.metamodel.flask.entities.http import FLASK_HTTP_PROCESSOR, FLASK_RESPONSE_PROCESSOR
 
 FLASK_METHODS = [
     {
         "package": "flask.app",
         "object": "Flask",
         "method": "wsgi_app",
-        "span_name": "Flask.wsgi_app",
         "wrapper_method": task_wrapper,
         "span_handler": "flask_handler",
+        "output_processor": FLASK_HTTP_PROCESSOR,
+    },
+    {
+        "package": "werkzeug.wrappers.response",
+        "object": "Response",
+        "method": "__call__",
+        "wrapper_method": task_wrapper,
+        "span_handler": "flask_response_handler",
+        "output_processor": FLASK_RESPONSE_PROCESSOR,
         "skip_span": True
     }
 ]

monocle_apptrace/instrumentation/metamodel/haystack/_helper.py

@@ -1,4 +1,5 @@
 import logging
+
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
     get_keys_as_tuple,
@@ -11,13 +12,19 @@ logger = logging.getLogger(__name__)
 def extract_messages(kwargs):
     try:
         messages = []
+        system_message, user_message = None,None
         if isinstance(kwargs, dict):
             if 'system_prompt' in kwargs and kwargs['system_prompt']:
                 system_message = kwargs['system_prompt']
-                messages.append({"system" : system_message})
             if 'prompt' in kwargs and kwargs['prompt']:
                 user_message = extract_question_from_prompt(kwargs['prompt'])
+            if 'messages' in kwargs and len(kwargs['messages'])>1:
+                system_message = kwargs['messages'][0].text
+                user_message = kwargs['messages'][1].text
+            if system_message and user_message:
+                messages.append({"system": system_message})
                 messages.append({"user": user_message})
+
         return [str(message) for message in messages]
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
@@ -52,6 +59,8 @@ def extract_assistant_message(response):
             reply = response["replies"][0]
             if hasattr(reply, 'content'):
                 return [reply.content]
+            if hasattr(reply, 'text'):
+                return [reply.text]
             return [reply]
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
@@ -108,15 +117,19 @@ def extract_embeding_model(instance):
 
 def update_span_from_llm_response(response, instance):
     meta_dict = {}
-    if response is not None and isinstance(response, dict) and "meta" in response:
-        token_usage = response["meta"][0]["usage"]
+    token_usage = None
+    if response is not None and isinstance(response, dict):
+        if "meta" in response:
+            token_usage = response["meta"][0]["usage"]
+        if "replies" in response:
+            token_usage = response["replies"][0].meta["usage"]
         if token_usage is not None:
             temperature = instance.__dict__.get("temperature", None)
             meta_dict.update({"temperature": temperature})
             meta_dict.update(
                 {"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")})
+            meta_dict.update({"total_tokens": token_usage.get("total_tokens") or token_usage.get("completion_tokens")+token_usage.get("prompt_tokens")})
     return meta_dict
 
 

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

@@ -1,6 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.haystack import (
     _helper,
 )
+from monocle_apptrace.instrumentation.common.utils import get_llm_type
 
 INFERENCE = {
     "type": "inference",
@@ -9,7 +10,9 @@ INFERENCE = {
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.azure_openai'
+#                "accessor": lambda arguments: 'inference.azure_openai'
+                "accessor": lambda arguments: 'inference.' + (get_llm_type(arguments['instance']) or 'generic')
+
             },
             {
                 "attribute": "provider_name",

monocle_apptrace/instrumentation/metamodel/haystack/methods.py

@@ -7,7 +7,6 @@ HAYSTACK_METHODS = [
         "package": "haystack.components.retrievers.in_memory",
         "object": "InMemoryEmbeddingRetriever",
         "method": "run",
-        "span_name": "haystack.retriever",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -15,7 +14,6 @@ HAYSTACK_METHODS = [
         "package": "haystack_integrations.components.retrievers.opensearch",
         "object": "OpenSearchEmbeddingRetriever",
         "method": "run",
-        "span_name": "haystack.retriever",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -37,7 +35,13 @@ HAYSTACK_METHODS = [
         "package": "haystack.core.pipeline.pipeline",
         "object": "Pipeline",
         "method": "run",
+        "wrapper_method": task_wrapper
+    },
+    {
+        "package": "haystack_integrations.components.generators.anthropic",
+        "object": "AnthropicChatGenerator",
+        "method": "run",
         "wrapper_method": task_wrapper,
-        "span_type": "workflow"
-    }
+        "output_processor": INFERENCE
+    },
 ]

monocle_apptrace/instrumentation/metamodel/langchain/_helper.py

@@ -50,14 +50,22 @@ def extract_assistant_message(response):
 
 
 def extract_provider_name(instance):
-    provider_url: Option[str] = try_option(getattr, instance.client._client.base_url, 'host')
+    provider_url: Option[str] = None
+    if hasattr(instance,'client'):
+        provider_url: Option[str] = try_option(getattr, instance.client._client.base_url, 'host')
+    if hasattr(instance, '_client'):
+        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] = 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)
+    inference_endpoint: Option[str] = None
+    if hasattr(instance,'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)
 
     return inference_endpoint.unwrap_or(extract_provider_name(instance))
 

monocle_apptrace/instrumentation/metamodel/langchain/methods.py

@@ -11,15 +11,13 @@ LANGCHAIN_METHODS = [
         "package": "langchain.prompts.base",
         "object": "BasePromptTemplate",
         "method": "invoke",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "langchain.prompts.base",
         "object": "BasePromptTemplate",
         "method": "ainvoke",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "langchain.chat_models.base",
@@ -82,30 +80,24 @@ LANGCHAIN_METHODS = [
         "package": "langchain.schema",
         "object": "BaseOutputParser",
         "method": "invoke",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "langchain.schema",
         "object": "BaseOutputParser",
         "method": "ainvoke",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "langchain.schema.runnable",
         "object": "RunnableSequence",
         "method": "invoke",
-        "span_name": "langchain.workflow",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "langchain.schema.runnable",
         "object": "RunnableSequence",
         "method": "ainvoke",
-        "span_name": "langchain.workflow",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     }
 ]

monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py

@@ -96,12 +96,19 @@ def extract_query_from_content(content):
 
 
 def extract_provider_name(instance):
-    provider_url = try_option(getattr, instance, 'api_base').and_then(lambda url: urlparse(url).hostname)
-    return provider_url
+    if hasattr(instance,'api_base'):
+        provider_url: Option[str]= try_option(getattr, instance, 'api_base').and_then(lambda url: urlparse(url).hostname)
+    if hasattr(instance,'_client'):
+        provider_url:Option[str] = try_option(getattr, instance._client.base_url,'host')
+    return provider_url.unwrap_or(None)
 
 
 def extract_inference_endpoint(instance):
-    inference_endpoint = try_option(getattr, instance._client.sdk_configuration, 'server_url').map(str)
+    if hasattr(instance,'_client'):
+        if hasattr(instance._client,'sdk_configuration'):
+            inference_endpoint: Option[str] = try_option(getattr, instance._client.sdk_configuration, 'server_url').map(str)
+        if hasattr(instance._client,'base_url'):
+            inference_endpoint: Option[str] = try_option(getattr, instance._client, 'base_url').map(str)
     return inference_endpoint.unwrap_or(extract_provider_name(instance))
 
 
@@ -163,10 +170,7 @@ def update_span_from_llm_response(response, instance):
             if token_usage is not None:
                 temperature = instance.__dict__.get("temperature", None)
                 meta_dict.update({"temperature": temperature})
-                if getattr(token_usage, "completion_tokens", None):
-                    meta_dict.update({"completion_tokens": getattr(token_usage, "completion_tokens")})
-                if getattr(token_usage, "prompt_tokens", None):
-                    meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens")})
-                if getattr(token_usage, "total_tokens", None):
-                    meta_dict.update({"total_tokens": getattr(token_usage, "total_tokens")})
+                meta_dict.update({"completion_tokens": getattr(token_usage, "completion_tokens",None) or getattr(token_usage,"output_tokens",None)})
+                meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens",None) or getattr(token_usage,"input_tokens",None)})
+                meta_dict.update({"total_tokens": getattr(token_usage, "total_tokens",None) or getattr(token_usage,"output_tokens",None)+getattr(token_usage,"input_tokens",None)})
     return meta_dict

monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py

@@ -13,7 +13,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "retrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -21,7 +20,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "aretrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": atask_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -29,23 +27,18 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "query",
-        "span_name": "llamaindex.query",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "aquery",
-        "span_name": "llamaindex.query",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "chat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -53,7 +46,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "achat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE,
         
@@ -62,7 +54,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "chat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -70,7 +61,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "achat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -78,7 +68,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "chat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -86,7 +75,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "achat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -94,8 +82,21 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.agent",
         "object": "ReActAgent",
         "method": "chat",
-        "span_name": "react.agent",
         "wrapper_method": task_wrapper,
         "output_processor": AGENT
+    },
+    {
+        "package": "llama_index.llms.anthropic",
+        "object": "Anthropic",
+        "method": "chat",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "llama_index.llms.anthropic",
+        "object": "Anthropic",
+        "method": "achat",
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
     }
 ]