langchain-dev-utils 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

langchain_dev_utils/__init__.py

@@ -1 +1 @@
-__version__ = "1.3.2"
+__version__ = "1.3.4"

langchain_dev_utils/agents/__init__.py

@@ -1,4 +1,4 @@
 from .factory import create_agent
-from .wrap import wrap_agent_as_tool
+from .wrap import wrap_agent_as_tool, wrap_all_agents_as_tool
 
-__all__ = ["create_agent", "wrap_agent_as_tool"]
+__all__ = ["create_agent", "wrap_agent_as_tool", "wrap_all_agents_as_tool"]

langchain_dev_utils/agents/middleware/handoffs.py

@@ -78,7 +78,19 @@ def _transform_agent_config(
         dict[str, AgentConfig]: The transformed agent config.
     """
 
+    new_config = {}
     for agent_name, _cfg in config.items():
+        new_config[agent_name] = {}
+
+        if "model" in _cfg:
+            new_config[agent_name]["model"] = _cfg["model"]
+        if "prompt" in _cfg:
+            new_config[agent_name]["prompt"] = _cfg["prompt"]
+        if "default" in _cfg:
+            new_config[agent_name]["default"] = _cfg["default"]
+        if "tools" in _cfg:
+            new_config[agent_name]["tools"] = _cfg["tools"]
+
         handoffs = _cfg.get("handoffs", [])
         if handoffs == "all":
             handoff_tools = [
@@ -102,8 +114,11 @@ def _transform_agent_config(
                 ]
             ]
 
-        _cfg["tools"] = [*_cfg.get("tools", []), *handoff_tools]
-    return config
+        new_config[agent_name]["tools"] = [
+            *new_config[agent_name].get("tools", []),
+            *handoff_tools,
+        ]
+    return new_config
 
 
 class HandoffAgentMiddleware(AgentMiddleware):

langchain_dev_utils/agents/wrap.py

@@ -5,11 +5,8 @@ from langchain.tools import ToolRuntime
 from langchain_core.messages import AnyMessage, HumanMessage
 from langchain_core.tools import BaseTool, StructuredTool
 from langgraph.graph.state import CompiledStateGraph
-from pydantic import BaseModel, Field
 
-
-class AgentToolInput(BaseModel):
-    request: str = Field(description="The input to the agent")
+from langchain_dev_utils.message_convert import format_sequence
 
 
 def _process_input(request: str, runtime: ToolRuntime) -> str:
@@ -138,3 +135,140 @@ def wrap_agent_as_tool(
         name=tool_name,
         description=tool_description,
     )
+
+
+def wrap_all_agents_as_tool(
+    agents: list[CompiledStateGraph],
+    tool_name: Optional[str] = None,
+    tool_description: Optional[str] = None,
+    pre_input_hooks: Optional[
+        tuple[
+            Callable[[str, ToolRuntime], str],
+            Callable[[str, ToolRuntime], Awaitable[str]],
+        ]
+        | Callable[[str, ToolRuntime], str]
+    ] = None,
+    post_output_hooks: Optional[
+        tuple[
+            Callable[[str, list[AnyMessage], ToolRuntime], Any],
+            Callable[[str, list[AnyMessage], ToolRuntime], Awaitable[Any]],
+        ]
+        | Callable[[str, list[AnyMessage], ToolRuntime], Any]
+    ] = None,
+) -> BaseTool:
+    """Wraps all agents as single tool
+
+    Args:
+        agents: The agents to wrap
+        tool_name: The name of the tool, default to "task"
+        tool_description: The description of the tool
+        pre_input_hooks: Hooks to run before the input is processed
+        post_output_hooks: Hooks to run after the output is processed
+
+    Returns:
+        BaseTool: The wrapped agents as single tool
+
+    Example:
+        >>> from langchain_dev_utils.agents import wrap_all_agents_as_tool, create_agent
+        >>>
+        >>> call_agent_tool = wrap_all_agents_as_tool(
+        ...     [time_agent,weather_agent],
+        ...     tool_name="call_sub_agents",
+        ...     tool_description="Used to invoke the sub-agents to perform tasks"
+        ... )
+        >>>
+        >>> agent = create_agent("vllm:qwen3-4b", tools=[call_sub_agents_tool], name="agent")
+
+        >>> response = agent.invoke({"messages": [HumanMessage(content="What time is it now?")]})
+        >>> response
+    """
+    if len(agents) <= 1:
+        raise ValueError("At least more than one agent must be provided")
+
+    agents_map = {}
+
+    for agent in agents:
+        if agent.name is None:
+            raise ValueError("Agent name must not be provided")
+        if agent.name in agents_map:
+            raise ValueError("Agent name must be unique")
+        agents_map[agent.name] = agent
+
+    process_input = _process_input
+    process_input_async = _process_input
+    process_output = _process_output
+    process_output_async = _process_output
+
+    if pre_input_hooks:
+        if isinstance(pre_input_hooks, tuple):
+            process_input = pre_input_hooks[0]
+            process_input_async = pre_input_hooks[1]
+        else:
+            process_input = pre_input_hooks
+            process_input_async = pre_input_hooks
+
+    if post_output_hooks:
+        if isinstance(post_output_hooks, tuple):
+            process_output = post_output_hooks[0]
+            process_output_async = post_output_hooks[1]
+        else:
+            process_output = post_output_hooks
+            process_output_async = post_output_hooks
+
+    def call_agent(
+        agent_name: str,
+        description: str,
+        runtime: ToolRuntime,
+    ) -> str:
+        task_description = (
+            process_input(description, runtime) if process_input else description
+        )
+
+        if agent_name not in agents_map:
+            raise ValueError(f"Agent {agent_name} not found")
+
+        messages = [HumanMessage(content=task_description)]
+        response = agents_map[agent_name].invoke({"messages": messages})
+
+        response = process_output(task_description, response["messages"], runtime)
+        return response
+
+    async def acall_agent(
+        agent_name: str,
+        description: str,
+        runtime: ToolRuntime,
+    ) -> str:
+        if asyncio.iscoroutinefunction(process_input_async):
+            task_description = await process_input_async(description, runtime)
+        else:
+            task_description = cast(str, process_input_async(description, runtime))
+
+        if agent_name not in agents_map:
+            raise ValueError(f"Agent {agent_name} not found")
+
+        messages = [HumanMessage(content=task_description)]
+        response = await agents_map[agent_name].ainvoke({"messages": messages})
+
+        if asyncio.iscoroutinefunction(process_output_async):
+            response = await process_output_async(
+                task_description, response["messages"], runtime
+            )
+        else:
+            response = process_output(task_description, response["messages"], runtime)
+
+        return response
+
+    if tool_name is None:
+        tool_name = "task"
+
+    if tool_description is None:
+        tool_description = (
+            "Launch an ephemeral subagent for a task.\nAvailable agents:\n "
+            + format_sequence(list(agents_map.keys()), with_num=True)
+        )
+    return StructuredTool.from_function(
+        func=call_agent,
+        coroutine=acall_agent,
+        name=tool_name,
+        description=tool_description,
+    )

langchain_dev_utils/chat_models/adapters/__init__.py

@@ -0,0 +1,3 @@
+from .create_utils import create_openai_compatible_model
+
+__all__ = ["create_openai_compatible_model"]

langchain_dev_utils/chat_models/adapters/create_utils.py

@@ -0,0 +1,53 @@
+from typing import Any, Optional, cast
+
+from langchain_core.utils import from_env
+
+from langchain_dev_utils._utils import _check_pkg_install
+
+from ..types import CompatibilityOptions
+
+
+def create_openai_compatible_model(
+    model_provider: str,
+    base_url: Optional[str] = None,
+    compatibility_options: Optional[CompatibilityOptions] = None,
+    model_profiles: Optional[dict[str, dict[str, Any]]] = None,
+    chat_model_cls_name: Optional[str] = None,
+):
+    """Factory function for creating provider-specific OpenAI-compatible model classes.
+
+    Dynamically generates model classes for different OpenAI-compatible providers,
+    configuring environment variable mappings and default base URLs specific to each provider.
+
+    Args:
+        model_provider (str): Identifier for the OpenAI-compatible provider (e.g. `vllm`, `moonshot`)
+        base_url (Optional[str], optional): Default API base URL for the provider. Defaults to None. If not provided, will try to use the environment variable.
+        compatibility_options (Optional[CompatibilityOptions], optional): Optional configuration for compatibility options with the provider. Defaults to None.
+        model_profiles (Optional[dict[str, dict[str, Any]]], optional): Optional model profiles for the provider. Defaults to None.
+        chat_model_cls_name (Optional[str], optional): Optional custom class name for the generated model. Defaults to None.
+    Returns:
+        Type[_BaseChatOpenAICompatible]: Configured model class ready for instantiation with provider-specific settings
+
+    Examples:
+        >>> from langchain_dev_utils.chat_models.adapters import create_openai_compatible_chat_model
+        >>> ChatVLLM = create_openai_compatible_chat_model(
+        ...     "vllm",
+        ...     base_url="http://localhost:8000",
+        ...     chat_model_cls_name="ChatVLLM",
+        ... )
+        >>> model = ChatVLLM(model="qwen3-4b")
+        >>> model.invoke("hello")
+    """
+    _check_pkg_install("langchain_openai")
+    from .openai_compatible import _create_openai_compatible_model
+
+    base_url = (
+        base_url or from_env(f"{model_provider.upper()}_API_BASE", default=None)()
+    )
+    return _create_openai_compatible_model(
+        chat_model_cls_name=chat_model_cls_name,
+        provider=model_provider,
+        base_url=cast(str, base_url),
+        compatibility_options=compatibility_options,
+        profiles=model_profiles,
+    )

langchain_dev_utils/chat_models/adapters/openai_compatible.py

@@ -12,6 +12,7 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    cast,
 )
 
 import openai
@@ -19,7 +20,11 @@ from langchain_core.callbacks import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain_core.language_models import LangSmithParams, LanguageModelInput
+from langchain_core.language_models import (
+    LangSmithParams,
+    LanguageModelInput,
+    ModelProfile,
+)
 from langchain_core.messages import (
     AIMessage,
     AIMessageChunk,
@@ -51,6 +56,10 @@ from ..types import (
     ResponseFormatType,
     ToolChoiceType,
 )
+from .register_profiles import (
+    _get_profile_by_provider_and_model,
+    _register_profile_with_provider,
+)
 
 _BM = TypeVar("_BM", bound=BaseModel)
 _DictOrPydanticClass = Union[dict[str, Any], type[_BM], type]
@@ -152,7 +161,7 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
     Note: This is a template class and should not be exported or instantiated
     directly. Instead, use it as a base class and provide the specific provider
     name through inheritance or the factory function
-    `_create_openai_compatible_model()`.
+    `create_openai_compatible_model()`.
     """
 
     model_name: str = Field(alias="model", default="openai compatible model")
@@ -283,7 +292,10 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
     def _set_model_profile(self) -> Self:
         """Set model profile if not overridden."""
         if self.profile is None:
-            self.profile = {}
+            self.profile = cast(
+                ModelProfile,
+                _get_profile_by_provider_and_model(self._provider, self.model_name),
+            )
         return self
 
     def _create_chat_result(
@@ -578,6 +590,8 @@ def _create_openai_compatible_model(
     provider: str,
     base_url: str,
     compatibility_options: Optional[CompatibilityOptions] = None,
+    profiles: Optional[dict[str, dict[str, Any]]] = None,
+    chat_model_cls_name: Optional[str] = None,
 ) -> Type[_BaseChatOpenAICompatible]:
     """Factory function for creating provider-specific OpenAI-compatible model classes.
 
@@ -588,14 +602,19 @@ def _create_openai_compatible_model(
         provider: Provider identifier (e.g.`vllm`)
         base_url: Default API base URL for the provider
         compatibility_options: Optional configuration for the provider
+        profiles: Optional profiles for the provider
+        chat_model_cls_name: Optional name for the model class
 
     Returns:
         Configured model class ready for instantiation with provider-specific settings
     """
-    chat_model_cls_name = f"Chat{provider.title()}"
+    chat_model_cls_name = chat_model_cls_name or f"Chat{provider.title()}"
     if compatibility_options is None:
         compatibility_options = {}
 
+    if profiles is not None:
+        _register_profile_with_provider(provider, profiles)
+
     return create_model(
         chat_model_cls_name,
         __base__=_BaseChatOpenAICompatible,

langchain_dev_utils/chat_models/adapters/register_profiles.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+_PROFILES = {}
+
+
+def _register_profile_with_provider(
+    provider_name: str, profile: dict[str, Any]
+) -> None:
+    _PROFILES.update({provider_name: profile})
+
+
+def _get_profile_by_provider_and_model(
+    provider_name: str, model_name: str
+) -> dict[str, Any]:
+    return _PROFILES.get(provider_name, {}).get(model_name, {})

langchain_dev_utils/chat_models/base.py

@@ -141,19 +141,12 @@ def register_model_provider(
                 "when chat_model is a string, the value must be 'openai-compatible'"
             )
         chat_model = _create_openai_compatible_model(
-            provider_name,
-            base_url,
+            provider=provider_name,
+            base_url=base_url,
             compatibility_options=compatibility_options,
+            profiles=model_profiles,
         )
-        _MODEL_PROVIDERS_DICT.update(
-            {
-                provider_name: {
-                    "chat_model": chat_model,
-                    "base_url": base_url,
-                    "model_profiles": model_profiles,
-                }
-            }
-        )
+        _MODEL_PROVIDERS_DICT.update({provider_name: {"chat_model": chat_model}})
     else:
         if base_url is not None:
             _MODEL_PROVIDERS_DICT.update(

langchain_dev_utils/embeddings/adapters/__init__.py

@@ -0,0 +1,3 @@
+from .create_utils import create_openai_compatible_embedding
+
+__all__ = ["create_openai_compatible_embedding"]

langchain_dev_utils/embeddings/adapters/create_utils.py

@@ -0,0 +1,45 @@
+from typing import Optional, cast
+
+from langchain_core.utils import from_env
+
+from langchain_dev_utils._utils import _check_pkg_install
+
+
+def create_openai_compatible_embedding(
+    embedding_provider: str,
+    base_url: Optional[str] = None,
+    embedding_model_cls_name: Optional[str] = None,
+):
+    """Factory function for creating provider-specific OpenAI-compatible embedding classes.
+
+    Dynamically generates embedding classes for different OpenAI-compatible providers,
+    configuring environment variable mappings and default base URLs specific to each provider.
+
+    Args:
+        embedding_provider (str): Identifier for the OpenAI-compatible provider (e.g. `vllm`, `moonshot`)
+        base_url (Optional[str], optional): Default API base URL for the provider. Defaults to None. If not provided, will try to use the environment variable.
+        embedding_model_cls_name (Optional[str], optional): Optional custom class name for the generated embedding. Defaults to None.
+    Returns:
+        Type[_BaseEmbeddingOpenAICompatible]: Configured embedding class ready for instantiation with provider-specific settings
+
+    Examples:
+        >>> from langchain_dev_utils.embeddings.adapters import create_openai_compatible_embedding
+        >>> VLLMEmbedding = create_openai_compatible_embedding(
+        ...     "vllm",
+        ...     base_url="http://localhost:8000",
+        ...     embedding_model_cls_name="VLLMEmbedding",
+        ... )
+        >>> model = VLLMEmbedding(model="qwen3-embedding-8b")
+        >>> model.embed_query("hello")
+    """
+    _check_pkg_install("langchain_openai")
+    from .openai_compatible import _create_openai_compatible_embedding
+
+    base_url = (
+        base_url or from_env(f"{embedding_provider.upper()}_API_BASE", default=None)()
+    )
+    return _create_openai_compatible_embedding(
+        provider=embedding_provider,
+        base_url=cast(str, base_url),
+        embeddings_cls_name=embedding_model_cls_name,
+    )

langchain_dev_utils/embeddings/adapters/openai_compatible.py

@@ -0,0 +1,75 @@
+from typing import Optional, Type
+
+from langchain_core.utils import from_env, secret_from_env
+from langchain_openai.embeddings import OpenAIEmbeddings
+from pydantic import Field, SecretStr, create_model
+
+
+class _BaseEmbeddingOpenAICompatible(OpenAIEmbeddings):
+    """Base class for OpenAI-Compatible embeddings.
+
+    This class extends the OpenAIEmbeddings class to support
+    custom API keys and base URLs for OpenAI-Compatible models.
+
+    Note: This is a template class and should not be exported or instantiated
+    directly. Instead, use it as a base class and provide the specific provider
+    name through inheritance or the factory function
+    `create_openai_compatible_embedding()`.
+    """
+
+    openai_api_key: Optional[SecretStr] = Field(
+        default_factory=secret_from_env("OPENAI_COMPATIBLE_API_KEY", default=None),
+        alias="api_key",
+    )
+    """OpenAI Compatible API key"""
+    openai_api_base: str = Field(
+        default_factory=from_env("OPENAI_COMPATIBLE_API_BASE", default=""),
+        alias="base_url",
+    )
+    """OpenAI Compatible API base URL"""
+
+    check_embedding_ctx_length: bool = False
+    """Whether to check the token length of inputs and automatically split inputs
+        longer than embedding_ctx_length. Defaults to False. """
+
+
+def _create_openai_compatible_embedding(
+    provider: str,
+    base_url: str,
+    embeddings_cls_name: Optional[str] = None,
+) -> Type[_BaseEmbeddingOpenAICompatible]:
+    """Factory function for creating provider-specific OpenAI-compatible embeddings classes.
+
+    Dynamically generates embeddings classes for different OpenAI-compatible providers,
+    configuring environment variable mappings and default base URLs specific to each provider.
+
+    Args:
+        provider: Provider identifier (e.g.`vllm`)
+        base_url: Default API base URL for the provider
+        embeddings_cls_name: Optional custom class name for the generated embeddings. Defaults to None.
+
+    Returns:
+        Configured embeddings class ready for instantiation with provider-specific settings
+    """
+    embeddings_cls_name = embeddings_cls_name or f"{provider.title()}Embeddings"
+
+    return create_model(
+        embeddings_cls_name,
+        __base__=_BaseEmbeddingOpenAICompatible,
+        openai_api_base=(
+            str,
+            Field(
+                default_factory=from_env(
+                    f"{provider.upper()}_API_BASE", default=base_url
+                ),
+            ),
+        ),
+        openai_api_key=(
+            str,
+            Field(
+                default_factory=secret_from_env(
+                    f"{provider.upper()}_API_KEY", default=None
+                ),
+            ),
+        ),
+    )

langchain_dev_utils/embeddings/base.py

@@ -1,7 +1,7 @@
 from typing import Any, Literal, NotRequired, Optional, TypedDict, Union
 
 from langchain.embeddings.base import _SUPPORTED_PROVIDERS, Embeddings, init_embeddings
-from langchain_core.utils import from_env, secret_from_env
+from langchain_core.utils import from_env
 
 from langchain_dev_utils._utils import (
     _check_pkg_install,
@@ -101,12 +101,16 @@ def register_embeddings_provider(
             )
 
         _check_pkg_install("langchain_openai")
+        from .adapters.openai_compatible import _create_openai_compatible_embedding
 
+        embeddings_model = _create_openai_compatible_embedding(
+            provider=provider_name,
+            base_url=base_url,
+        )
         _EMBEDDINGS_PROVIDERS_DICT.update(
             {
                 provider_name: {
                     "embeddings_model": embeddings_model,
-                    "base_url": base_url,
                 }
             }
         )
@@ -220,28 +224,10 @@ def load_embeddings(
 
     if provider in _EMBEDDINGS_PROVIDERS_DICT:
         embeddings = _EMBEDDINGS_PROVIDERS_DICT[provider]["embeddings_model"]
-        if isinstance(embeddings, str):
-            if not (api_key := kwargs.get("api_key")):
-                api_key = secret_from_env(f"{provider.upper()}_API_KEY", default=None)()
-                if not api_key:
-                    raise ValueError(
-                        f"API key for {provider} not found. Please set it in the environment."
-                    )
-                kwargs["api_key"] = api_key
-                if embeddings == "openai-compatible":
-                    kwargs["check_embedding_ctx_length"] = False
-                    embeddings = "openai"
-            return init_embeddings(
-                model=model,
-                provider=embeddings,
-                base_url=_EMBEDDINGS_PROVIDERS_DICT[provider]["base_url"],
-                **kwargs,
-            )
-        else:
-            if base_url := _EMBEDDINGS_PROVIDERS_DICT[provider].get("base_url"):
-                url_key = _get_base_url_field_name(embeddings)
-                if url_key is not None:
-                    kwargs.update({url_key: base_url})
-            return embeddings(model=model, **kwargs)
+        if base_url := _EMBEDDINGS_PROVIDERS_DICT[provider].get("base_url"):
+            url_key = _get_base_url_field_name(embeddings)
+            if url_key is not None:
+                kwargs.update({url_key: base_url})
+        return embeddings(model=model, **kwargs)
     else:
         return init_embeddings(model, provider=provider, **kwargs)

langchain_dev_utils/message_convert/__init__.py

@@ -1,15 +1,15 @@
-from .content import (
-    aconvert_reasoning_content_for_chunk_iterator,
-    convert_reasoning_content_for_ai_message,
-    convert_reasoning_content_for_chunk_iterator,
-    merge_ai_message_chunk,
-)
-from .format import format_sequence
-
-__all__ = [
-    "convert_reasoning_content_for_ai_message",
-    "convert_reasoning_content_for_chunk_iterator",
-    "aconvert_reasoning_content_for_chunk_iterator",
-    "merge_ai_message_chunk",
-    "format_sequence",
-]
+from .content import (
+    aconvert_reasoning_content_for_chunk_iterator,
+    convert_reasoning_content_for_ai_message,
+    convert_reasoning_content_for_chunk_iterator,
+    merge_ai_message_chunk,
+)
+from .format import format_sequence
+
+__all__ = [
+    "convert_reasoning_content_for_ai_message",
+    "convert_reasoning_content_for_chunk_iterator",
+    "aconvert_reasoning_content_for_chunk_iterator",
+    "merge_ai_message_chunk",
+    "format_sequence",
+]

langchain_dev_utils/message_convert/format.py

@@ -1,69 +1,69 @@
-from typing import Sequence, Union
-
-from langchain_core.documents import Document
-from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
-    HumanMessage,
-    SystemMessage,
-    ToolMessage,
-)
-
-
-def format_sequence(
-    inputs: Union[Sequence[Document], Sequence[BaseMessage], Sequence[str]],
-    separator: str = "-",
-    with_num: bool = False,
-) -> str:
-    """Convert a list of messages, documents, or strings into a formatted string.
-
-    This function extracts text content from various types (e.g., HumanMessage, Document)
-    and joins them into a single string. Optionally adds serial numbers and a custom
-    separator between items.
-
-    Args:
-        inputs: A list of inputs. Supported types:
-            - langchain_core.messages: HumanMessage, AIMessage, SystemMessage, ToolMessage
-            - langchain_core.documents.Document
-            - str
-        separator: The separator used to join the items. Defaults to "-".
-        with_num: If True, prefixes each item with a serial number (e.g., "1. Hello").
-                  Defaults to False.
-
-    Returns:
-        A formatted string composed of the input contents, joined by `separator`.
-
-    Example:
-        # Format messages with default separator:
-        >>> from langchain_dev_utils.message_convert import format_sequence
-        >>> from langchain_core.messages import HumanMessage, AIMessage
-        >>> messages = [
-        ...     HumanMessage(content="Hello, how are you?"),
-        ...     AIMessage(content="I'm doing well, thank you!")
-        ... ]
-        >>> formatted = format_sequence(messages)
-        >>> formatted
-
-        # Format with custom separator and numbering:
-        >>> formatted = format_sequence(messages, separator="---", with_num=True)
-        >>> formatted
-    """
-    if not inputs:
-        return ""
-
-    outputs = []
-
-    for input_item in inputs:
-        if isinstance(
-            input_item, (HumanMessage, AIMessage, SystemMessage, ToolMessage)
-        ):
-            outputs.append(input_item.content)
-        elif isinstance(input_item, Document):
-            outputs.append(input_item.page_content)
-        elif isinstance(input_item, str):
-            outputs.append(input_item)
-    if with_num:
-        outputs = [f"{i + 1}. {output}" for i, output in enumerate(outputs)]
-
-    str_ = "\n" + separator
-    return separator + str_.join(outputs)
+from typing import Sequence, Union
+
+from langchain_core.documents import Document
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+
+
+def format_sequence(
+    inputs: Union[Sequence[Document], Sequence[BaseMessage], Sequence[str]],
+    separator: str = "-",
+    with_num: bool = False,
+) -> str:
+    """Convert a list of messages, documents, or strings into a formatted string.
+
+    This function extracts text content from various types (e.g., HumanMessage, Document)
+    and joins them into a single string. Optionally adds serial numbers and a custom
+    separator between items.
+
+    Args:
+        inputs: A list of inputs. Supported types:
+            - langchain_core.messages: HumanMessage, AIMessage, SystemMessage, ToolMessage
+            - langchain_core.documents.Document
+            - str
+        separator: The separator used to join the items. Defaults to "-".
+        with_num: If True, prefixes each item with a serial number (e.g., "1. Hello").
+                  Defaults to False.
+
+    Returns:
+        A formatted string composed of the input contents, joined by `separator`.
+
+    Example:
+        # Format messages with default separator:
+        >>> from langchain_dev_utils.message_convert import format_sequence
+        >>> from langchain_core.messages import HumanMessage, AIMessage
+        >>> messages = [
+        ...     HumanMessage(content="Hello, how are you?"),
+        ...     AIMessage(content="I'm doing well, thank you!")
+        ... ]
+        >>> formatted = format_sequence(messages)
+        >>> formatted
+
+        # Format with custom separator and numbering:
+        >>> formatted = format_sequence(messages, separator="---", with_num=True)
+        >>> formatted
+    """
+    if not inputs:
+        return ""
+
+    outputs = []
+
+    for input_item in inputs:
+        if isinstance(
+            input_item, (HumanMessage, AIMessage, SystemMessage, ToolMessage)
+        ):
+            outputs.append(input_item.content)
+        elif isinstance(input_item, Document):
+            outputs.append(input_item.page_content)
+        elif isinstance(input_item, str):
+            outputs.append(input_item)
+    if with_num:
+        outputs = [f"{i + 1}. {output}" for i, output in enumerate(outputs)]
+
+    str_ = "\n" + separator
+    return separator + str_.join(outputs)

{langchain_dev_utils-1.3.2.dist-info → langchain_dev_utils-1.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-dev-utils
-Version: 1.3.2
+Version: 1.3.4
 Summary: A practical utility library for LangChain and LangGraph development
 Project-URL: Source Code, https://github.com/TBice123123/langchain-dev-utils
 Project-URL: repository, https://github.com/TBice123123/langchain-dev-utils

{langchain_dev_utils-1.3.2.dist-info → langchain_dev_utils-1.3.4.dist-info}/RECORD

@@ -1,14 +1,14 @@
-langchain_dev_utils/__init__.py,sha256=HgKA3RqZvC7slo8MgLyffCGwJbQ3cY6I7oUMFvGLWps,22
+langchain_dev_utils/__init__.py,sha256=9qxIaE8bFi9OKpc20hJx4mYCCa26qBsDb5ixbbRmD9c,23
 langchain_dev_utils/_utils.py,sha256=MFEzR1BjXMj6HEVwt2x2omttFuDJ_rYAEbNqe99r9pM,1338
 langchain_dev_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_dev_utils/agents/__init__.py,sha256=PJ-lSDZv_AXMYA3H4fx-HzJa14tPbkGmq1HX8LNfaPo,125
+langchain_dev_utils/agents/__init__.py,sha256=69_biZzyJvW9OBT1g8TX_77mp9-I_TvWo9QtlvHq83E,177
 langchain_dev_utils/agents/factory.py,sha256=8XB6y_ddf58vXlTLHBL6KCirFqkD2GjtzsuOt98sS7U,3732
 langchain_dev_utils/agents/file_system.py,sha256=Yk3eetREE26WNrnTWLoiDUpOyCJ-rhjlfFDk6foLa1E,8468
 langchain_dev_utils/agents/plan.py,sha256=WwhoiJBmVYVI9bT8HfjCzTJ_SIp9WFil0gOeznv2omQ,6497
-langchain_dev_utils/agents/wrap.py,sha256=RuchoH_VotPmKFuYEn2SXoSgNxZhSA9jKM0Iv_8oHLk,4718
+langchain_dev_utils/agents/wrap.py,sha256=dJbCvljyw-ee43__2uws4H4ZhsyyX1AuavNtHrdWqN8,9485
 langchain_dev_utils/agents/middleware/__init__.py,sha256=QVQibaNHvHPyNTZ2UNFfYL153ZboaCHcoioTHK0FsiY,710
 langchain_dev_utils/agents/middleware/format_prompt.py,sha256=LzYiQXCRvkpfDhGPxhZwdepeU3j-HUWPJqcx3FWsfT4,2357
-langchain_dev_utils/agents/middleware/handoffs.py,sha256=hYtm6NKUvfJQ_fxtTBuvEay185_RCB0yXAEdgSL7-Ls,6721
+langchain_dev_utils/agents/middleware/handoffs.py,sha256=r196Xk0Jws1Tz6JQuvy5HEc3HAAQejCxFmJpB6KrvLU,7230
 langchain_dev_utils/agents/middleware/model_fallback.py,sha256=8xiNjTJ0yiRkPLCRfAGNnqY1TLstj1Anmiqyv5w2mA8,1633
 langchain_dev_utils/agents/middleware/model_router.py,sha256=qBspvj9ZoKfmC1pHWTO0EHHfxjgCUd-TuSbqvZl0kmg,7977
 langchain_dev_utils/agents/middleware/plan.py,sha256=-ZLkp85QQTSCX9thMblacJ1N86h0BYPoTwCfJlJ_jzQ,14981
@@ -17,15 +17,20 @@ langchain_dev_utils/agents/middleware/tool_call_repair.py,sha256=oZF0Oejemqs9kSn
 langchain_dev_utils/agents/middleware/tool_emulator.py,sha256=OgtPhqturaWzF4fRSJ3f_IXvIrYrrAjlpOC5zmLtrkY,2031
 langchain_dev_utils/agents/middleware/tool_selection.py,sha256=dRH5ejR6N02Djwxt6Gd63MYkg6SV5pySlzaRt53OoZk,3113
 langchain_dev_utils/chat_models/__init__.py,sha256=YSLUyHrWEEj4y4DtGFCOnDW02VIYZdfAH800m4Klgeg,224
-langchain_dev_utils/chat_models/base.py,sha256=BzaoCIv145eE8b5wNDsbZDHn4EAxe4vdlptp7qXPWKk,11625
+langchain_dev_utils/chat_models/base.py,sha256=X76uaPoJDOLRphFyyeFH_RgEIvPcMoZEZWuRtjPCpl0,11486
 langchain_dev_utils/chat_models/types.py,sha256=MD3cv_ZIe9fCdgwisNfuxAOhy-j4YSs1ZOQYyCjlNKs,927
-langchain_dev_utils/chat_models/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=ws1CTZhyl8gxoY_RCLsV3cDgc8d7yDLWUa6ZfloxuMs,24239
+langchain_dev_utils/chat_models/adapters/__init__.py,sha256=4tTbhAAQdpX_gWyWeH97hqS5HnaoqQqW6QBh9Qd1SKs,106
+langchain_dev_utils/chat_models/adapters/create_utils.py,sha256=r8_XWLNF3Yc6sumlBhmgG1QcBa4Dsba7X3f_9YeMeGA,2479
+langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=A3_NcmnsrCrHgm1-mGT-JqQVYUBsOzFH0KzSNX6edbY,24876
+langchain_dev_utils/chat_models/adapters/register_profiles.py,sha256=YS9ItCEq2ISoB_bp6QH5NVKOVR9-7la3r7B_xQNxZxE,366
 langchain_dev_utils/embeddings/__init__.py,sha256=zbEOaV86TUi9Zrg_dH9dpdgacWg31HMJTlTQknA9EKk,244
-langchain_dev_utils/embeddings/base.py,sha256=BGoWY0L7nG9iRV3d4sSagXhECXrwvS1xA-A_OVltn3k,9406
-langchain_dev_utils/message_convert/__init__.py,sha256=ZGrHGXPKMrZ_p9MqfIVZ4jgbEyb7aC4Q7X-muuThIYU,457
+langchain_dev_utils/embeddings/base.py,sha256=_no5sGEiBZENaHLWzwLB45tTsDj-bha7nt1GUhWBmP4,8731
+langchain_dev_utils/embeddings/adapters/__init__.py,sha256=yJEZZdzZ2fv1ExezLaNxo0VU9HJTHKYbS3T_XP8Ab9c,114
+langchain_dev_utils/embeddings/adapters/create_utils.py,sha256=K4JlbjG-O5xLY3wxaVt0UZ3QwI--cVb4qyxLATKVAWQ,2012
+langchain_dev_utils/embeddings/adapters/openai_compatible.py,sha256=fPX1GpJ6nwadbVu7mAMEVTIvGL2ZvtfRwkld2CJeHng,2767
+langchain_dev_utils/message_convert/__init__.py,sha256=nnkDa_Im0dCb5u4aa2FRB9tqB8e6H6sEGYK6Vg81u2s,472
 langchain_dev_utils/message_convert/content.py,sha256=2V1g21byg3iLv5RjUW8zv3jwYwV7IH2hNim7jGRsIes,8096
-langchain_dev_utils/message_convert/format.py,sha256=1TOcJ09atH7LRtn_IIuBshKDXAyqoy3Q9b0Po-S-F9g,2377
+langchain_dev_utils/message_convert/format.py,sha256=NdrYX0cJn2-G1ArLSjJ7yO788KV1d83F4Kimpyft0IM,2446
 langchain_dev_utils/pipeline/__init__.py,sha256=eE6WktaLHDkqMeXDIDaLtm-OPTwtsX_Av8iK9uYrceo,186
 langchain_dev_utils/pipeline/parallel.py,sha256=nwZWbdSNeyanC9WufoJBTceotgT--UnPOfStXjgNMOc,5271
 langchain_dev_utils/pipeline/sequential.py,sha256=sYJXQzVHDKUc-UV-HMv38JTPnse1A7sRM0vqSdpHK0k,3850
@@ -33,7 +38,7 @@ langchain_dev_utils/pipeline/types.py,sha256=T3aROKKXeWvd0jcH5XkgMDQfEkLfPaiOhhV
 langchain_dev_utils/tool_calling/__init__.py,sha256=mu_WxKMcu6RoTf4vkTPbA1WSBSNc6YIqyBtOQ6iVQj4,322
 langchain_dev_utils/tool_calling/human_in_the_loop.py,sha256=7Z_QO5OZUR6K8nLoIcafc6osnvX2IYNorOJcbx6bVso,9672
 langchain_dev_utils/tool_calling/utils.py,sha256=S4-KXQ8jWmpGTXYZitovF8rxKpaSSUkFruM8LDwvcvE,2765
-langchain_dev_utils-1.3.2.dist-info/METADATA,sha256=PLQKHjjqwlL9lvaW3Et1q0gYbZTtRdmTN6w5A4gJiYM,4552
-langchain_dev_utils-1.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-langchain_dev_utils-1.3.2.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
-langchain_dev_utils-1.3.2.dist-info/RECORD,,
+langchain_dev_utils-1.3.4.dist-info/METADATA,sha256=K8AGEzWWmv-5HYzuNmmu3tboFyikx9zZjoj7H8Pald0,4552
+langchain_dev_utils-1.3.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langchain_dev_utils-1.3.4.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
+langchain_dev_utils-1.3.4.dist-info/RECORD,,