symbolicai 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

symai/backend/engines/neurosymbolic/engine_anthropic_claudeX_chat.py

@@ -28,6 +28,7 @@ logging.getLogger("urllib").setLevel(logging.ERROR)
 logging.getLogger("httpx").setLevel(logging.ERROR)
 logging.getLogger("httpcore").setLevel(logging.ERROR)
 
+
 class TokenizerWrapper:
     def __init__(self, compute_tokens_func):
         self.compute_tokens_func = compute_tokens_func
@@ -35,18 +36,19 @@ class TokenizerWrapper:
     def encode(self, text: str) -> int:
         return self.compute_tokens_func([{"role": "user", "content": text}])
 
+
 class ClaudeXChatEngine(Engine, AnthropicMixin):
     def __init__(self, api_key: str | None = None, model: str | None = None):
         super().__init__()
         self.config = deepcopy(SYMAI_CONFIG)
         # In case we use EngineRepository.register to inject the api_key and model => dynamically change the engine at runtime
         if api_key is not None and model is not None:
-            self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] = api_key
-            self.config['NEUROSYMBOLIC_ENGINE_MODEL'] = model
-        if self.id() != 'neurosymbolic':
-            return # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
-        anthropic.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
-        self.model = self.config['NEUROSYMBOLIC_ENGINE_MODEL']
+            self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] = api_key
+            self.config["NEUROSYMBOLIC_ENGINE_MODEL"] = model
+        if self.id() != "neurosymbolic":
+            return  # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
+        anthropic.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        self.model = self.config["NEUROSYMBOLIC_ENGINE_MODEL"]
         self.name = self.__class__.__name__
         self.tokenizer = TokenizerWrapper(self.compute_required_tokens)
         self.max_context_tokens = self.api_max_context_tokens()
@@ -54,21 +56,25 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
         self.client = anthropic.Anthropic(api_key=anthropic.api_key)
 
     def id(self) -> str:
-        if self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and \
-           self.config.get('NEUROSYMBOLIC_ENGINE_MODEL').startswith('claude') and \
-           ('3-7' not in self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and \
-            '4-0' not in self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and \
-            '4-1' not in self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and \
-            '4-5' not in self.config.get('NEUROSYMBOLIC_ENGINE_MODEL')):
-               return 'neurosymbolic'
-        return super().id() # default to unregistered
+        if (
+            self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+            and self.config.get("NEUROSYMBOLIC_ENGINE_MODEL").startswith("claude")
+            and (
+                "3-7" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+                and "4-0" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+                and "4-1" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+                and "4-5" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+            )
+        ):
+            return "neurosymbolic"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'NEUROSYMBOLIC_ENGINE_API_KEY' in kwargs:
-            anthropic.api_key = kwargs['NEUROSYMBOLIC_ENGINE_API_KEY']
-        if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
+        if "NEUROSYMBOLIC_ENGINE_API_KEY" in kwargs:
+            anthropic.api_key = kwargs["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        if "NEUROSYMBOLIC_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["NEUROSYMBOLIC_ENGINE_MODEL"]
 
     def compute_required_tokens(self, messages) -> int:
         claude_messages, system_content = self._build_claude_messages(messages)
@@ -83,11 +89,11 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
         system_content = None
 
         for role, content_str in self._message_parts(messages):
-            if role == 'system':
+            if role == "system":
                 system_content = content_str
                 continue
 
-            if role in ['user', 'assistant']:
+            if role in ["user", "assistant"]:
                 message_content = self._build_message_content(content_str)
                 if message_content:
                     claude_messages.append(self._create_claude_message(role, message_content))
@@ -102,11 +108,11 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
 
     def _extract_message_details(self, part):
         if isinstance(part, str):
-            return 'user', part
+            return "user", part
 
         if isinstance(part, dict):
-            role = part.get('role')
-            content_str = str(part.get('content', ''))
+            role = part.get("role")
+            content_str = str(part.get("content", ""))
             return role, content_str
 
         msg = f"Unsupported message part type: {type(part)}"
@@ -121,33 +127,21 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
 
         text_content = self._remove_vision_pattern(content_str)
         if text_content:
-            message_content.append({
-                "type": "text",
-                "text": text_content
-            })
+            message_content.append({"type": "text", "text": text_content})
 
         return message_content
 
     def _create_claude_message(self, role: str, message_content: list) -> dict:
-        if len(message_content) == 1 and message_content[0].get('type') == 'text':
-            return {
-                'role': role,
-                'content': message_content[0]['text']
-            }
+        if len(message_content) == 1 and message_content[0].get("type") == "text":
+            return {"role": role, "content": message_content[0]["text"]}
 
-        return {
-            'role': role,
-            'content': message_content
-        }
+        return {"role": role, "content": message_content}
 
     def _count_claude_tokens(self, claude_messages: list, system_content: str | None) -> int:
         try:
-            count_params = {
-                'model': self.model,
-                'messages': claude_messages
-            }
+            count_params = {"model": self.model, "messages": claude_messages}
             if system_content:
-                count_params['system'] = system_content
+                count_params["system"] = system_content
             count_response = self.client.messages.count_tokens(**count_params)
             return count_response.input_tokens
         except Exception as e:
@@ -155,16 +149,17 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
             UserMessage(f"Error counting tokens for Claude: {e!s}", raise_with=RuntimeError)
 
     def compute_remaining_tokens(self, _prompts: list) -> int:
-        UserMessage('Method not implemented.', raise_with=NotImplementedError)
+        UserMessage("Method not implemented.", raise_with=NotImplementedError)
 
     def _handle_image_content(self, content: str) -> list:
         """Handle image content by processing vision patterns and returning image file data."""
+
         def extract_pattern(text):
-            pattern = r'<<vision:(.*?):>>'
+            pattern = r"<<vision:(.*?):>>"
             return re.findall(pattern, text)
 
         image_files = []
-        if '<<vision:' in content:
+        if "<<vision:" in content:
             parts = extract_pattern(content)
             for p in parts:
                 img_ = p.strip()
@@ -172,89 +167,94 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
                 max_used_frames = 10
                 buffer, ext = encode_media_frames(img_)
                 if len(buffer) > 1:
-                    step = len(buffer) // max_frames_spacing # max frames spacing
+                    step = len(buffer) // max_frames_spacing  # max frames spacing
                     frames = []
                     indices = list(range(0, len(buffer), step))[:max_used_frames]
                     for i in indices:
-                        frames.append({'data': buffer[i], 'media_type': f'image/{ext}', 'type': 'base64'})
+                        frames.append(
+                            {"data": buffer[i], "media_type": f"image/{ext}", "type": "base64"}
+                        )
                     image_files.extend(frames)
                 elif len(buffer) == 1:
-                    image_files.append({'data': buffer[0], 'media_type': f'image/{ext}', 'type': 'base64'})
+                    image_files.append(
+                        {"data": buffer[0], "media_type": f"image/{ext}", "type": "base64"}
+                    )
                 else:
-                    UserMessage('No frames found for image!')
+                    UserMessage("No frames found for image!")
         return image_files
 
     def _remove_vision_pattern(self, text: str) -> str:
         """Remove vision patterns from text."""
-        pattern = r'<<vision:(.*?):>>'
-        return re.sub(pattern, '', text)
+        pattern = r"<<vision:(.*?):>>"
+        return re.sub(pattern, "", text)
 
     def forward(self, argument):
         kwargs = argument.kwargs
         system, messages = argument.prop.prepared_input
         payload = self._prepare_request_payload(argument)
-        except_remedy = kwargs.get('except_remedy')
+        except_remedy = kwargs.get("except_remedy")
 
         try:
-            res = self.client.messages.create(
-                system=system,
-                messages=messages,
-                **payload
-            )
+            res = self.client.messages.create(system=system, messages=messages, **payload)
         except Exception as e:
-            if anthropic.api_key is None or anthropic.api_key == '':
-                msg = 'Anthropic API key is not set. Please set it in the config file or pass it as an argument to the command method.'
+            if anthropic.api_key is None or anthropic.api_key == "":
+                msg = "Anthropic API key is not set. Please set it in the config file or pass it as an argument to the command method."
                 UserMessage(msg)
-                if self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] is None or self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] == '':
+                if (
+                    self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] is None
+                    or self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] == ""
+                ):
                     UserMessage(msg, raise_with=ValueError)
-                anthropic.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
+                anthropic.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
 
             callback = self.client.messages.create
-            kwargs['model'] = kwargs.get('model', self.model)
+            kwargs["model"] = kwargs.get("model", self.model)
 
             if except_remedy is not None:
                 res = except_remedy(self, e, callback, argument)
             else:
-                UserMessage(f'Error during generation. Caused by: {e}', raise_with=ValueError)
+                UserMessage(f"Error during generation. Caused by: {e}", raise_with=ValueError)
 
-        if payload['stream']:
-            res = list(res) # Unpack the iterator to a list
-        metadata = {'raw_output': res}
+        if payload["stream"]:
+            res = list(res)  # Unpack the iterator to a list
+        metadata = {"raw_output": res}
         response_data = self._collect_response(res)
 
-        if response_data.get('function_call'):
-            metadata['function_call'] = response_data['function_call']
+        if response_data.get("function_call"):
+            metadata["function_call"] = response_data["function_call"]
 
-        text_output = response_data.get('text', '')
+        text_output = response_data.get("text", "")
         if argument.prop.response_format:
             # Anthropic returns JSON in markdown format
-            text_output = text_output.replace('```json', '').replace('```', '')
+            text_output = text_output.replace("```json", "").replace("```", "")
 
         return [text_output], metadata
 
     def _prepare_raw_input(self, argument):
         if not argument.prop.processed_input:
-            msg = 'Need to provide a prompt instruction to the engine if `raw_input` is enabled!'
+            msg = "Need to provide a prompt instruction to the engine if `raw_input` is enabled!"
             UserMessage(msg)
             raise ValueError(msg)
         system = NOT_GIVEN
         prompt = copy(argument.prop.processed_input)
         if not isinstance(prompt, list):
             if not isinstance(prompt, dict):
-                prompt = {'role': 'user', 'content': str(prompt)}
+                prompt = {"role": "user", "content": str(prompt)}
             prompt = [prompt]
         if len(prompt) > 1:
             # assert there are not more than 1 system instruction
-            assert len([p for p in prompt if p['role'] == 'system']) <= 1, 'Only one system instruction is allowed!'
+            assert len([p for p in prompt if p["role"] == "system"]) <= 1, (
+                "Only one system instruction is allowed!"
+            )
             for p in prompt:
-                if p['role'] == 'system':
-                    system = p['content']
+                if p["role"] == "system":
+                    system = p["content"]
                     prompt.remove(p)
                     break
         return system, prompt
 
     def prepare(self, argument):
-        #@NOTE: OpenAI compatibility at high level
+        # @NOTE: OpenAI compatibility at high level
         if argument.prop.raw_input:
             argument.prop.prepared_input = self._prepare_raw_input(argument)
             return
@@ -265,7 +265,9 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
 
         system = self._build_system_prompt(argument, has_image, non_verbose_output)
         user_text, user_prompt, image_blocks = self._build_user_prompt(argument, image_files)
-        system, user_prompt = self._apply_self_prompt_if_needed(argument, system, user_text, image_blocks, user_prompt)
+        system, user_prompt = self._apply_self_prompt_if_needed(
+            argument, system, user_text, image_blocks, user_prompt
+        )
 
         argument.prop.prepared_input = (system, [user_prompt])
 
@@ -280,13 +282,15 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
         if argument.prop.suppress_verbose_output:
             system += non_verbose_output
 
-        system = f'{system}\n' if system and len(system) > 0 else ''
+        system = f"{system}\n" if system and len(system) > 0 else ""
 
         if argument.prop.response_format:
             response_format = argument.prop.response_format
-            assert response_format.get('type') is not None, 'Response format type is required! Expected format `{"type": str}`! The str value will be passed to the engine. Refer to the Anthropic documentation for more information: https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/increase-consistency#example-standardizing-customer-feedback'
+            assert response_format.get("type") is not None, (
+                'Response format type is required! Expected format `{"type": str}`! The str value will be passed to the engine. Refer to the Anthropic documentation for more information: https://docs.anthropic.com/en/docs/test-and-evaluate/strengthen-guardrails/increase-consistency#example-standardizing-customer-feedback'
+            )
             system += non_verbose_output
-            system += f'<RESPONSE_FORMAT/>\n{response_format["type"]}\n\n'
+            system += f"<RESPONSE_FORMAT/>\n{response_format['type']}\n\n"
 
         return system
 
@@ -321,7 +325,7 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
 
     def _append_template_suffix(self, system: str, argument) -> str:
         if argument.prop.template_suffix:
-            system += f' You will only generate content for the placeholder `{argument.prop.template_suffix!s}` following the instructions and the provided context information.\n\n'
+            system += f" You will only generate content for the placeholder `{argument.prop.template_suffix!s}` following the instructions and the provided context information.\n\n"
 
         return system
 
@@ -334,59 +338,58 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
         if not user_text:
             user_text = "N/A"
 
-        image_blocks = [{'type': 'image', 'source': image_file} for image_file in image_files]
+        image_blocks = [{"type": "image", "source": image_file} for image_file in image_files]
         user_prompt = self._wrap_user_prompt_content(user_text, image_blocks)
         return user_text, user_prompt, image_blocks
 
     def _wrap_user_prompt_content(self, user_text: str, image_blocks: list[dict]) -> dict:
         if len(image_blocks) > 0:
-            return {
-                "role": "user",
-                "content": [
-                    *image_blocks,
-                    {'type': 'text', 'text': user_text}
-                ]
-            }
+            return {"role": "user", "content": [*image_blocks, {"type": "text", "text": user_text}]}
 
-        return {
-            "role": "user",
-            "content": user_text
-        }
+        return {"role": "user", "content": user_text}
 
-    def _apply_self_prompt_if_needed(self, argument, system: str, user_text: str, image_blocks: list[dict], user_prompt: dict):
-        if not (argument.prop.instance._kwargs.get('self_prompt', False) or argument.prop.self_prompt):
+    def _apply_self_prompt_if_needed(
+        self, argument, system: str, user_text: str, image_blocks: list[dict], user_prompt: dict
+    ):
+        if not (
+            argument.prop.instance._kwargs.get("self_prompt", False) or argument.prop.self_prompt
+        ):
             return system, user_prompt
 
         self_prompter = SelfPrompt()
-        res = self_prompter({'user': user_text, 'system': system})
+        res = self_prompter({"user": user_text, "system": system})
         if res is None:
             msg = "Self-prompting failed!"
             UserMessage(msg)
             raise ValueError(msg)
 
-        updated_user_prompt = self._wrap_user_prompt_content(res['user'], image_blocks)
-        return res['system'], updated_user_prompt
+        updated_user_prompt = self._wrap_user_prompt_content(res["user"], image_blocks)
+        return res["system"], updated_user_prompt
 
     def _prepare_request_payload(self, argument):
         kwargs = argument.kwargs
-        model = kwargs.get('model', self.model)
-        max_tokens = kwargs.get('max_tokens', self.max_response_tokens)
-        stop = kwargs.get('stop', NOT_GIVEN)
-        temperature = kwargs.get('temperature', 1)
-        top_p = kwargs.get('top_p', NOT_GIVEN if temperature is not None else 1) #@NOTE:'You should either alter temperature or top_p, but not both.'
-        top_k = kwargs.get('top_k', NOT_GIVEN)
-        stream = kwargs.get('stream', True) # Do NOT remove this default value! Getting tons of API errors because they can't process requests >10m
-        tools = kwargs.get('tools', NOT_GIVEN)
-        tool_choice = kwargs.get('tool_choice', NOT_GIVEN)
-        metadata_anthropic = kwargs.get('metadata', NOT_GIVEN)
+        model = kwargs.get("model", self.model)
+        max_tokens = kwargs.get("max_tokens", self.max_response_tokens)
+        stop = kwargs.get("stop", NOT_GIVEN)
+        temperature = kwargs.get("temperature", 1)
+        top_p = kwargs.get(
+            "top_p", NOT_GIVEN if temperature is not None else 1
+        )  # @NOTE:'You should either alter temperature or top_p, but not both.'
+        top_k = kwargs.get("top_k", NOT_GIVEN)
+        stream = kwargs.get(
+            "stream", True
+        )  # Do NOT remove this default value! Getting tons of API errors because they can't process requests >10m
+        tools = kwargs.get("tools", NOT_GIVEN)
+        tool_choice = kwargs.get("tool_choice", NOT_GIVEN)
+        metadata_anthropic = kwargs.get("metadata", NOT_GIVEN)
 
         if stop != NOT_GIVEN and not isinstance(stop, list):
             stop = [stop]
 
-        #@NOTE: Anthropic fails if stop is not raw string, so cast it to r'…'
+        # @NOTE: Anthropic fails if stop is not raw string, so cast it to r'…'
         #       E.g. when we use defaults in core.py, i.e. stop=['\n']
         if stop != NOT_GIVEN:
-            stop = [r'{s}' for s in stop]
+            stop = [r"{s}" for s in stop]
 
         return {
             "model": model,
@@ -398,7 +401,7 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
             "stream": stream,
             "metadata": metadata_anthropic,
             "tools": tools,
-            "tool_choice": tool_choice
+            "tool_choice": tool_choice,
         }
 
     def _collect_response(self, res):
@@ -408,7 +411,9 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
         if isinstance(res, Message):
             return self._collect_message_response(res)
 
-        UserMessage(f"Unexpected response type from Anthropic API: {type(res)}", raise_with=ValueError)
+        UserMessage(
+            f"Unexpected response type from Anthropic API: {type(res)}", raise_with=ValueError
+        )
         return {}
 
     def _collect_streaming_response(self, res):
@@ -426,27 +431,24 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
                 if tool_call is not None:
                     tool_calls_raw.append(tool_call)
 
-        text_content = ''.join(text_parts)
+        text_content = "".join(text_parts)
         function_call_data = self._build_function_call_data(tool_calls_raw)
 
-        return {
-            "text": text_content,
-            "function_call": function_call_data
-        }
+        return {"text": text_content, "function_call": function_call_data}
 
     def _start_tool_call(self, chunk, active_tool_calls: dict):
         if isinstance(chunk.content_block, ToolUseBlock):
             active_tool_calls[chunk.index] = {
-                'id': chunk.content_block.id,
-                'name': chunk.content_block.name,
-                'input_json_str': ""
+                "id": chunk.content_block.id,
+                "name": chunk.content_block.name,
+                "input_json_str": "",
             }
 
     def _update_stream_chunk(self, chunk, text_parts: list, active_tool_calls: dict):
         if isinstance(chunk.delta, TextDelta):
             text_parts.append(chunk.delta.text)
         elif isinstance(chunk.delta, InputJSONDelta) and chunk.index in active_tool_calls:
-            active_tool_calls[chunk.index]['input_json_str'] += chunk.delta.partial_json
+            active_tool_calls[chunk.index]["input_json_str"] += chunk.delta.partial_json
 
     def _finish_tool_call(self, chunk, active_tool_calls: dict):
         if chunk.index not in active_tool_calls:
@@ -454,10 +456,12 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
 
         tool_call_info = active_tool_calls.pop(chunk.index)
         try:
-            tool_call_info['input'] = json.loads(tool_call_info['input_json_str'])
+            tool_call_info["input"] = json.loads(tool_call_info["input_json_str"])
         except json.JSONDecodeError as e:
-            UserMessage(f"Failed to parse JSON for tool call {tool_call_info['name']}: {e}. Raw JSON: '{tool_call_info['input_json_str']}'")
-            tool_call_info['input'] = {}
+            UserMessage(
+                f"Failed to parse JSON for tool call {tool_call_info['name']}: {e}. Raw JSON: '{tool_call_info['input_json_str']}'"
+            )
+            tool_call_info["input"] = {}
         return tool_call_info
 
     def _build_function_call_data(self, tool_calls_raw: list | None) -> dict | None:
@@ -465,13 +469,12 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
             return None
 
         if len(tool_calls_raw) > 1:
-            UserMessage("Multiple tool calls detected in the stream but only the first one will be processed.")
+            UserMessage(
+                "Multiple tool calls detected in the stream but only the first one will be processed."
+            )
 
         tool_call = tool_calls_raw[0]
-        return {
-            'name': tool_call['name'],
-            'arguments': tool_call['input']
-        }
+        return {"name": tool_call["name"], "arguments": tool_call["input"]}
 
     def _collect_message_response(self, res: Message):
         text_parts = []
@@ -483,15 +486,14 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
                 text_parts.append(content_block.text)
             elif isinstance(content_block, ToolUseBlock):
                 if hit_tool_use:
-                    UserMessage("Multiple tool use blocks detected in the response but only the first one will be processed.")
+                    UserMessage(
+                        "Multiple tool use blocks detected in the response but only the first one will be processed."
+                    )
                 else:
                     function_call_data = {
-                        'name': content_block.name,
-                        'arguments': content_block.input
+                        "name": content_block.name,
+                        "arguments": content_block.input,
                     }
                     hit_tool_use = True
 
-        return {
-            "text": ''.join(text_parts),
-            "function_call": function_call_data
-        }
+        return {"text": "".join(text_parts), "function_call": function_call_data}