chatterer 0.1.13__py3-none-any.whl → 0.1.16__py3-none-any.whl

chatterer/language_model.py

@@ -1,3 +1,4 @@
+import re
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -5,13 +6,13 @@ from typing import (
     Callable,
     Iterable,
     Iterator,
+    Literal,
     Optional,
     Self,
     Sequence,
     Type,
     TypeAlias,
     TypeVar,
-    cast,
     overload,
 )
 
@@ -19,10 +20,11 @@ from langchain_core.language_models.base import LanguageModelInput
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.runnables.base import Runnable
 from langchain_core.runnables.config import RunnableConfig
-from pydantic import BaseModel, Field
+from langchain_core.utils.utils import secret_from_env
+from pydantic import BaseModel, Field, SecretStr
 
-from .messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
-from .utils.code_agent import CodeExecutionResult, FunctionSignature, get_default_repl_tool
+from .messages import AIMessage, BaseMessage, HumanMessage, UsageMetadata
+from .utils.code_agent import CodeExecutionResult, FunctionSignature, augment_prompt_for_toolcall
 
 if TYPE_CHECKING:
     from instructor import Partial
@@ -53,6 +55,8 @@ DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT = (
 )
 DEFAULT_FUNCTION_REFERENCE_SEPARATOR = "\n---\n"  # Separator to distinguish different function references
 
+PYTHON_CODE_PATTERN: re.Pattern[str] = re.compile(r"```(?:python\s*\n)?(.*?)```", re.DOTALL)
+
 
 class Chatterer(BaseModel):
     """Language model for generating text from a given input."""
@@ -60,71 +64,82 @@ class Chatterer(BaseModel):
     client: BaseChatModel
     structured_output_kwargs: dict[str, Any] = Field(default_factory=dict)
 
-    @overload
-    def __call__(
-        self,
-        messages: LanguageModelInput,
-        response_model: Type[PydanticModelT],
-        config: Optional[RunnableConfig] = None,
-        stop: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> PydanticModelT: ...
-
-    @overload
-    def __call__(
-        self,
-        messages: LanguageModelInput,
-        response_model: None = None,
-        config: Optional[RunnableConfig] = None,
-        stop: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> str: ...
+    @classmethod
+    def from_provider(
+        cls, provider_and_model: str, structured_output_kwargs: Optional[dict[str, object]] = {"strict": True}
+    ) -> Self:
+        backend, model = provider_and_model.split(":", 1)
+        backends = cls.get_backends()
+        if func := backends.get(backend):
+            return func(model, structured_output_kwargs)
+        else:
+            raise ValueError(f"Unsupported provider: {backend}. Supported providers are: {', '.join(backends.keys())}.")
 
-    def __call__(
-        self,
-        messages: LanguageModelInput,
-        response_model: Optional[Type[PydanticModelT]] = None,
-        config: Optional[RunnableConfig] = None,
-        stop: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> str | PydanticModelT:
-        if response_model:
-            return self.generate_pydantic(response_model, messages, config, stop, **kwargs)
-        return self.client.invoke(input=messages, config=config, stop=stop, **kwargs).text()
+    @classmethod
+    def get_backends(cls) -> dict[str, Callable[[str, Optional[dict[str, object]]], Self]]:
+        return {
+            "openai": cls.openai,
+            "anthropic": cls.anthropic,
+            "google": cls.google,
+            "ollama": cls.ollama,
+            "openrouter": cls.open_router,
+            "xai": cls.xai,
+        }
 
     @classmethod
     def openai(
         cls,
-        model: str = "gpt-4o-mini",
-        structured_output_kwargs: Optional[dict[str, Any]] = {"strict": True},
+        model: str = "gpt-4.1",
+        structured_output_kwargs: Optional[dict[str, object]] = {"strict": True},
+        api_key: Optional[str] = None,
+        **kwargs: Any,
     ) -> Self:
         from langchain_openai import ChatOpenAI
 
-        return cls(client=ChatOpenAI(model=model), structured_output_kwargs=structured_output_kwargs or {})
+        return cls(
+            client=ChatOpenAI(
+                model=model,
+                api_key=_get_api_key(api_key=api_key, env_key="OPENAI_API_KEY", raise_if_none=False),
+                **kwargs,
+            ),
+            structured_output_kwargs=structured_output_kwargs or {},
+        )
 
     @classmethod
     def anthropic(
         cls,
         model_name: str = "claude-3-7-sonnet-20250219",
-        structured_output_kwargs: Optional[dict[str, Any]] = None,
+        structured_output_kwargs: Optional[dict[str, object]] = None,
+        api_key: Optional[str] = None,
+        **kwargs: Any,
     ) -> Self:
         from langchain_anthropic import ChatAnthropic
 
         return cls(
-            client=ChatAnthropic(model_name=model_name, timeout=None, stop=None),
+            client=ChatAnthropic(
+                model_name=model_name,
+                api_key=_get_api_key(api_key=api_key, env_key="ANTHROPIC_API_KEY", raise_if_none=True),
+                **kwargs,
+            ),
             structured_output_kwargs=structured_output_kwargs or {},
         )
 
     @classmethod
     def google(
         cls,
-        model: str = "gemini-2.0-flash",
-        structured_output_kwargs: Optional[dict[str, Any]] = None,
+        model: str = "gemini-2.5-flash-preview-04-17",
+        structured_output_kwargs: Optional[dict[str, object]] = None,
+        api_key: Optional[str] = None,
+        **kwargs: Any,
     ) -> Self:
         from langchain_google_genai import ChatGoogleGenerativeAI
 
         return cls(
-            client=ChatGoogleGenerativeAI(model=model),
+            client=ChatGoogleGenerativeAI(
+                model=model,
+                api_key=_get_api_key(api_key=api_key, env_key="GOOGLE_API_KEY", raise_if_none=False),
+                **kwargs,
+            ),
             structured_output_kwargs=structured_output_kwargs or {},
         )
 
@@ -132,15 +147,112 @@ class Chatterer(BaseModel):
     def ollama(
         cls,
         model: str = "deepseek-r1:1.5b",
-        structured_output_kwargs: Optional[dict[str, Any]] = None,
+        structured_output_kwargs: Optional[dict[str, object]] = None,
+        **kwargs: Any,
     ) -> Self:
         from langchain_ollama import ChatOllama
 
         return cls(
-            client=ChatOllama(model=model),
+            client=ChatOllama(model=model, **kwargs),
+            structured_output_kwargs=structured_output_kwargs or {},
+        )
+
+    @classmethod
+    def open_router(
+        cls,
+        model: str = "openrouter/quasar-alpha",
+        structured_output_kwargs: Optional[dict[str, object]] = None,
+        api_key: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Self:
+        from langchain_openai import ChatOpenAI
+
+        return cls(
+            client=ChatOpenAI(
+                model=model,
+                base_url="https://openrouter.ai/api/v1",
+                api_key=_get_api_key(api_key=api_key, env_key="OPENROUTER_API_KEY", raise_if_none=False),
+                **kwargs,
+            ),
             structured_output_kwargs=structured_output_kwargs or {},
         )
 
+    @classmethod
+    def xai(
+        cls,
+        model: str = "grok-3-mini",
+        structured_output_kwargs: Optional[dict[str, object]] = None,
+        base_url: str = "https://api.x.ai/v1",
+        api_key: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Self:
+        from langchain_openai import ChatOpenAI
+
+        return cls(
+            client=ChatOpenAI(
+                model=model,
+                base_url=base_url,
+                api_key=_get_api_key(api_key=api_key, env_key="XAI_API_KEY", raise_if_none=False),
+                **kwargs,
+            ),
+            structured_output_kwargs=structured_output_kwargs or {},
+        )
+
+    @property
+    def invoke(self):
+        return self.client.invoke
+
+    @property
+    def ainvoke(self):
+        return self.client.ainvoke
+
+    @property
+    def stream(self):
+        return self.client.stream
+
+    @property
+    def astream(self):
+        return self.client.astream
+
+    @property
+    def bind_tools(self):  # pyright: ignore[reportUnknownParameterType]
+        return self.client.bind_tools  # pyright: ignore[reportUnknownParameterType, reportUnknownVariableType, reportUnknownMemberType]
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.client, name)
+
+    @overload
+    def __call__(
+        self,
+        messages: LanguageModelInput,
+        response_model: Type[PydanticModelT],
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> PydanticModelT: ...
+
+    @overload
+    def __call__(
+        self,
+        messages: LanguageModelInput,
+        response_model: None = None,
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> str: ...
+
+    def __call__(
+        self,
+        messages: LanguageModelInput,
+        response_model: Optional[Type[PydanticModelT]] = None,
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> str | PydanticModelT:
+        if response_model:
+            return self.generate_pydantic(response_model, messages, config, stop, **kwargs)
+        return self.client.invoke(input=messages, config=config, stop=stop, **kwargs).text()
+
     def generate(
         self,
         messages: LanguageModelInput,
@@ -279,41 +391,32 @@ class Chatterer(BaseModel):
             )
         ])
 
-    @staticmethod
-    def get_num_tokens_from_message(message: BaseMessage) -> Optional[tuple[int, int]]:
-        try:
-            if isinstance(message, AIMessage) and (usage_metadata := message.usage_metadata):
-                input_tokens = int(usage_metadata["input_tokens"])
-                output_tokens = int(usage_metadata["output_tokens"])
+    def get_approximate_token_count(self, message: BaseMessage) -> int:
+        return self.client.get_num_tokens_from_messages([message])  # pyright: ignore[reportUnknownMemberType]
+
+    def get_usage_metadata(self, message: BaseMessage) -> UsageMetadata:
+        if isinstance(message, AIMessage):
+            usage_metadata = message.usage_metadata
+            if usage_metadata is not None:
+                input_tokens = usage_metadata["input_tokens"]
+                output_tokens = usage_metadata["output_tokens"]
+                return {
+                    "input_tokens": input_tokens,
+                    "output_tokens": output_tokens,
+                    "total_tokens": input_tokens + output_tokens,
+                }
             else:
-                # Dynamic extraction for unknown structures
-                input_tokens: Optional[int] = None
-                output_tokens: Optional[int] = None
-
-                def _find_tokens(obj: object) -> None:
-                    nonlocal input_tokens, output_tokens
-                    if isinstance(obj, dict):
-                        for key, value in cast(dict[object, object], obj).items():
-                            if isinstance(value, int):
-                                if "input" in str(key) or "prompt" in str(key):
-                                    input_tokens = value
-                                elif "output" in str(key) or "completion" in str(key):
-                                    output_tokens = value
-                            else:
-                                _find_tokens(value)
-                    elif isinstance(obj, list):
-                        for item in cast(list[object], obj):
-                            _find_tokens(item)
-
-                _find_tokens(message.model_dump())
-
-            if input_tokens is None or output_tokens is None:
-                return None
-            return input_tokens, output_tokens
-        except Exception:
-            return None
-
-    def invoke_code_execution(
+                approx_tokens = self.get_approximate_token_count(message)
+                return {"input_tokens": 0, "output_tokens": approx_tokens, "total_tokens": approx_tokens}
+        else:
+            approx_tokens = self.get_approximate_token_count(message)
+            return {
+                "input_tokens": approx_tokens,
+                "output_tokens": 0,
+                "total_tokens": approx_tokens,
+            }
+
+    def exec(
         self,
         messages: LanguageModelInput,
         repl_tool: Optional["PythonAstREPLTool"] = None,
@@ -347,7 +450,12 @@ class Chatterer(BaseModel):
             **kwargs,
         )
 
-    async def ainvoke_code_execution(
+    @property
+    def invoke_code_execution(self) -> Callable[..., CodeExecutionResult]:
+        """Alias for exec method for backward compatibility."""
+        return self.exec
+
+    async def aexec(
         self,
         messages: LanguageModelInput,
         repl_tool: Optional["PythonAstREPLTool"] = None,
@@ -378,10 +486,24 @@ class Chatterer(BaseModel):
             **kwargs,
         )
 
+    @property
+    def ainvoke_code_execution(self):
+        """Alias for aexec method for backward compatibility."""
+        return self.aexec
+
 
 class PythonCodeToExecute(BaseModel):
     code: str = Field(description="Python code to execute")
 
+    def model_post_init(self, context: object) -> None:
+        super().model_post_init(context)
+
+        codes: list[str] = []
+        for match in PYTHON_CODE_PATTERN.finditer(self.code):
+            codes.append(match.group(1))
+        if codes:
+            self.code = "\n".join(codes)
+
 
 def _with_structured_output(
     client: BaseChatModel,
@@ -391,187 +513,21 @@ def _with_structured_output(
     return client.with_structured_output(schema=response_model, **structured_output_kwargs)  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
 
 
-# def _add_message_last(messages: LanguageModelInput, prompt_to_add: str) -> LanguageModelInput:
-#     if isinstance(messages, str):
-#         messages += f"\n{prompt_to_add}"
-#     elif isinstance(messages, Sequence):
-#         messages = list(messages)
-#         messages.append(SystemMessage(content=prompt_to_add))
-#     else:
-#         messages = messages.to_messages()
-#         messages.append(SystemMessage(content=prompt_to_add))
-#     return messages
-
-
-def _add_message_first(messages: LanguageModelInput, prompt_to_add: str) -> LanguageModelInput:
-    if isinstance(messages, str):
-        messages = f"{prompt_to_add}\n{messages}"
-    elif isinstance(messages, Sequence):
-        messages = list(messages)
-        messages.insert(0, SystemMessage(content=prompt_to_add))
-    else:
-        messages = messages.to_messages()
-        messages.insert(0, SystemMessage(content=prompt_to_add))
-    return messages
-
-
-def augment_prompt_for_toolcall(
-    function_signatures: Iterable[FunctionSignature],
-    messages: LanguageModelInput,
-    prompt_for_code_invoke: Optional[str] = DEFAULT_CODE_GENERATION_PROMPT,
-    function_reference_prefix: Optional[str] = DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT,
-    function_reference_seperator: str = DEFAULT_FUNCTION_REFERENCE_SEPARATOR,
-) -> LanguageModelInput:
-    if function_signatures:
-        messages = _add_message_first(
-            messages=messages,
-            prompt_to_add=FunctionSignature.as_prompt(
-                function_signatures, function_reference_prefix, function_reference_seperator
-            ),
-        )
-    if prompt_for_code_invoke:
-        messages = _add_message_first(messages=messages, prompt_to_add=prompt_for_code_invoke)
-    return messages
-
-
-def interactive_shell(
-    chatterer: Chatterer = Chatterer.openai(),
-    system_instruction: BaseMessage | Iterable[BaseMessage] = ([
-        SystemMessage("You are an AI that can answer questions and execute Python code."),
-    ]),
-    repl_tool: Optional["PythonAstREPLTool"] = None,
-    prompt_for_code_invoke: Optional[str] = DEFAULT_CODE_GENERATION_PROMPT,
-    additional_callables: Optional[Callable[..., object] | Sequence[Callable[..., object]]] = None,
-    function_reference_prefix: Optional[str] = DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT,
-    function_reference_seperator: str = DEFAULT_FUNCTION_REFERENCE_SEPARATOR,
-    config: Optional[RunnableConfig] = None,
-    stop: Optional[list[str]] = None,
-    **kwargs: Any,
-) -> None:
-    from rich.console import Console
-    from rich.prompt import Prompt
-
-    # 코드 실행 필요 여부를 판단하는 모델
-    class IsCodeExecutionNeeded(BaseModel):
-        is_code_execution_needed: bool = Field(
-            description="Whether Python tool calling is needed to answer user query."
-        )
-
-    # 추가 코드 실행 필요 여부를 판단하는 모델
-    class IsFurtherCodeExecutionNeeded(BaseModel):
-        review_on_code_execution: str = Field(description="Review on the code execution.")
-        next_action: str = Field(description="Next action to take.")
-        is_further_code_execution_needed: bool = Field(
-            description="Whether further Python tool calling is needed to answer user query."
-        )
-
-    def respond(messages: list[BaseMessage]) -> str:
-        # AI 응답 스트리밍 출력
-        console.print("[bold blue]AI:[/bold blue] ", end="")
-        response = ""
-        for chunk in chatterer.generate_stream(messages=messages):
-            response += chunk
-            console.print(chunk, end="")
-        console.print()  # 응답 후 줄바꿈 추가
-        return response.strip()
-
-    def code_session_returning_end_of_turn() -> bool:
-        code_session_messages: list[BaseMessage] = []
-        while True:
-            code_execution: CodeExecutionResult = chatterer.invoke_code_execution(
-                messages=context,
-                repl_tool=repl_tool,
-                prompt_for_code_invoke=prompt_for_code_invoke,
-                function_signatures=function_signatures,
-                function_reference_prefix=function_reference_prefix,
-                function_reference_seperator=function_reference_seperator,
-                config=config,
-                stop=stop,
-                **kwargs,
-            )
-            if code_execution.code.strip() in ("", "quit", "exit", "pass"):
-                return False
-
-            last_tool_use_message = AIMessage(
-                content=f"Executed code:\n```python\n{code_execution.code}\n```\nOutput:\n{code_execution.output}".strip()
-            )
-            code_session_messages.append(last_tool_use_message)
-            console.print("[bold yellow]Executed code:[/bold yellow]")
-            console.print(f"[code]{code_execution.code}[/code]")
-            console.print("[bold yellow]Output:[/bold yellow]")
-            console.print(code_execution.output)
-
-            decision = chatterer.generate_pydantic(
-                response_model=IsFurtherCodeExecutionNeeded,
-                messages=augment_prompt_for_toolcall(
-                    function_signatures=function_signatures,
-                    messages=context + code_session_messages,
-                    prompt_for_code_invoke=prompt_for_code_invoke,
-                    function_reference_prefix=function_reference_prefix,
-                    function_reference_seperator=function_reference_seperator,
-                ),
-            )
-            review_on_code_execution = decision.review_on_code_execution.strip()
-            next_action = decision.next_action.strip()
-            console.print("[bold blue]AI:[/bold blue]")
-            console.print(f"-[bold yellow]Review on code execution:[/bold yellow] {review_on_code_execution}")
-            console.print(f"-[bold yellow]Next Action:[/bold yellow] {next_action}")
-            code_session_messages.append(
-                AIMessage(
-                    content=f"- Review upon code execution: {review_on_code_execution}\n- Next Action: {next_action}".strip()
+@overload
+def _get_api_key(api_key: Optional[str], env_key: str, raise_if_none: Literal[True]) -> SecretStr: ...
+@overload
+def _get_api_key(api_key: Optional[str], env_key: str, raise_if_none: Literal[False]) -> Optional[SecretStr]: ...
+def _get_api_key(api_key: Optional[str], env_key: str, raise_if_none: bool) -> Optional[SecretStr]:
+    if api_key is None:
+        api_key_found: SecretStr | None = secret_from_env(env_key, default=None)()
+        if raise_if_none and api_key_found is None:
+            raise ValueError(
+                (
+                    f"Did not find API key, please add an environment variable"
+                    f" `{env_key}` which contains it, or pass"
+                    f" api_key as a named parameter."
                 )
             )
-            if not decision.is_further_code_execution_needed:
-                response: str = respond(context + code_session_messages)
-                context.append(last_tool_use_message)
-                context.append(AIMessage(content=response))
-                return True
-
-    # REPL 도구 초기화
-    if repl_tool is None:
-        repl_tool = get_default_repl_tool()
-
-    function_signatures: list[FunctionSignature] = FunctionSignature.from_callable(additional_callables)
-    console = Console()
-    context: list[BaseMessage] = []
-    if system_instruction:
-        if isinstance(system_instruction, BaseMessage):
-            context.append(system_instruction)
-        else:
-            context.extend(system_instruction)
-
-    # 환영 메시지
-    console.print("[bold blue]Welcome to the Interactive Chatterer Shell![/bold blue]")
-    console.print("Type 'quit' or 'exit' to end the conversation.")
-
-    while True:
-        # 사용자 입력 받기
-        user_input = Prompt.ask("[bold green]You[/bold green]")
-        if user_input.lower() in ["quit", "exit"]:
-            console.print("[bold blue]Goodbye![/bold blue]")
-            break
-
-        context.append(HumanMessage(content=user_input))
-
-        # 코드 실행 필요 여부 판단
-        decision = chatterer.generate_pydantic(
-            response_model=IsCodeExecutionNeeded,
-            messages=augment_prompt_for_toolcall(
-                function_signatures=function_signatures,
-                messages=context,
-                prompt_for_code_invoke=prompt_for_code_invoke,
-                function_reference_prefix=function_reference_prefix,
-                function_reference_seperator=function_reference_seperator,
-            ),
-        )
-
-        # 코드 실행 처리
-        if decision.is_code_execution_needed and code_session_returning_end_of_turn():
-            continue
-
-        # AI 응답 스트리밍 출력
-        context.append(AIMessage(content=respond(context)))
-
-
-if __name__ == "__main__":
-    interactive_shell()
+        return api_key_found
+    else:
+        return SecretStr(api_key)

chatterer/messages.py

@@ -1,4 +1,13 @@
-from langchain_core.messages import AIMessage, BaseMessage, FunctionMessage, HumanMessage, SystemMessage
+from langchain_core.language_models.base import LanguageModelInput
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    BaseMessageChunk,
+    FunctionMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from langchain_core.messages.ai import UsageMetadata
 
 __all__ = [
     "AIMessage",
@@ -6,4 +15,7 @@ __all__ = [
     "HumanMessage",
     "SystemMessage",
     "FunctionMessage",
+    "BaseMessageChunk",
+    "UsageMetadata",
+    "LanguageModelInput",
 ]

chatterer/tools/__init__.py

@@ -1,26 +1,24 @@
+from .caption_markdown_images import MarkdownLink, acaption_markdown_images, caption_markdown_images
 from .citation_chunking import citation_chunker
+from .convert_pdf_to_markdown import PdfToMarkdown, extract_text_from_pdf, open_pdf, render_pdf_as_image
 from .convert_to_text import (
+    CodeSnippets,
     anything_to_markdown,
     get_default_html_to_markdown_options,
     html_to_markdown,
     pdf_to_text,
     pyscripts_to_snippets,
 )
+from .upstage_document_parser import UpstageDocumentParseParser
+from .webpage_to_markdown import (
+    PlayWrightBot,
+    PlaywrightLaunchOptions,
+    PlaywrightOptions,
+    PlaywrightPersistencyOptions,
+    get_default_playwright_launch_options,
+)
 from .youtube import get_youtube_video_details, get_youtube_video_subtitle
 
-
-def init_webpage_to_markdown():
-    from . import webpage_to_markdown
-
-    return webpage_to_markdown
-
-
-def init_upstage_document_parser():
-    from . import upstage_document_parser
-
-    return upstage_document_parser
-
-
 __all__ = [
     "html_to_markdown",
     "anything_to_markdown",
@@ -28,8 +26,21 @@ __all__ = [
     "get_default_html_to_markdown_options",
     "pyscripts_to_snippets",
     "citation_chunker",
-    "init_webpage_to_markdown",
+    "webpage_to_markdown",
     "get_youtube_video_subtitle",
     "get_youtube_video_details",
-    "init_upstage_document_parser",
+    "CodeSnippets",
+    "PlayWrightBot",
+    "PlaywrightLaunchOptions",
+    "PlaywrightOptions",
+    "PlaywrightPersistencyOptions",
+    "get_default_playwright_launch_options",
+    "UpstageDocumentParseParser",
+    "acaption_markdown_images",
+    "caption_markdown_images",
+    "MarkdownLink",
+    "PdfToMarkdown",
+    "extract_text_from_pdf",
+    "open_pdf",
+    "render_pdf_as_image",
 ]