langchain-dev-utils 1.3.7__py3-none-any.whl

langchain_dev_utils/pipeline/sequential.py

@@ -0,0 +1,101 @@
+from typing import Optional
+
+from langgraph.cache.base import BaseCache
+from langgraph.graph import StateGraph
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.store.base import BaseStore
+from langgraph.types import Checkpointer
+from langgraph.typing import ContextT, InputT, OutputT, StateT
+
+from .types import SubGraph
+
+
+def create_sequential_pipeline(
+    sub_graphs: list[SubGraph],
+    state_schema: type[StateT],
+    graph_name: Optional[str] = None,
+    context_schema: type[ContextT] | None = None,
+    input_schema: type[InputT] | None = None,
+    output_schema: type[OutputT] | None = None,
+    checkpointer: Checkpointer | None = None,
+    store: BaseStore | None = None,
+    cache: BaseCache | None = None,
+) -> CompiledStateGraph[StateT, ContextT, InputT, OutputT]:
+    """
+    Create a sequential pipeline from a list of subgraphs.
+
+    This function allows you to compose multiple StateGraphs in a sequential fashion,
+    where each subgraph executes one after another. This is useful for creating
+    complex multi-agent workflows where agents need to work in a specific order.
+
+    Args:
+        sub_graphs: List of sub-graphs to execute sequentially
+        state_schema: state schema of the final constructed graph
+        graph_name: Name of the final constructed graph
+        context_schema: context schema of the final constructed graph
+        input_schema: input schema of the final constructed graph
+        output_schema: output schema of the final constructed graph
+        checkpointer: Optional LangGraph checkpointer for the final constructed
+            graph
+        store: Optional LangGraph store for the final constructed graph
+        cache: Optional LangGraph cache for the final constructed graph
+
+    Returns:
+        CompiledStateGraph[StateT, ContextT, InputT, OutputT]: Compiled state
+            graph of the pipeline.
+
+    Example:
+        # Basic sequential pipeline with multiple specialized agents:
+        >>> from langchain_dev_utils.pipeline import create_sequential_pipeline
+        >>>
+        >>> graph = create_sequential_pipeline(
+        ...     sub_graphs=[
+        ...         time_agent, weather_agent, user_agent
+        ...     ],
+        ...     state_schema=AgentState,
+        ...     graph_name="sequential_agents_pipeline",
+        ... )
+        >>>
+        >>> response = graph.invoke({"messages": [HumanMessage("Hello")]})
+    """
+    graph = StateGraph(
+        state_schema=state_schema,
+        context_schema=context_schema,
+        input_schema=input_schema,
+        output_schema=output_schema,
+    )
+
+    subgraphs_names = set()
+
+    compiled_subgraphs: list[CompiledStateGraph] = []
+    for subgraph in sub_graphs:
+        if isinstance(subgraph, StateGraph):
+            subgraph = subgraph.compile()
+
+        compiled_subgraphs.append(subgraph)
+        if subgraph.name is None or subgraph.name == "LangGraph":
+            raise ValueError(
+                "Please specify a name when you create your agent, either via `create_react_agent(..., name=agent_name)` "
+                "or via `graph.compile(name=name)`."
+            )
+
+        if subgraph.name in subgraphs_names:
+            raise ValueError(
+                f"Subgraph with name '{subgraph.name}' already exists. Subgraph names must be unique."
+            )
+
+        subgraphs_names.add(subgraph.name)
+
+    graph.add_sequence(
+        [
+            (compiled_subgraphs[i].name, compiled_subgraphs[i])
+            for i in range(len(compiled_subgraphs))
+        ]
+    )
+    graph.add_edge("__start__", compiled_subgraphs[0].name)
+    return graph.compile(
+        name=graph_name or "sequential graph",
+        checkpointer=checkpointer,
+        store=store,
+        cache=cache,
+    )

langchain_dev_utils/pipeline/types.py

@@ -0,0 +1,3 @@
+from langgraph.graph.state import CompiledStateGraph, StateGraph
+
+SubGraph = StateGraph | CompiledStateGraph

langchain_dev_utils/tool_calling/__init__.py

@@ -0,0 +1,14 @@
+from .human_in_the_loop import (
+    InterruptParams,
+    human_in_the_loop,
+    human_in_the_loop_async,
+)
+from .utils import has_tool_calling, parse_tool_calling
+
+__all__ = [
+    "has_tool_calling",
+    "parse_tool_calling",
+    "human_in_the_loop",
+    "human_in_the_loop_async",
+    "InterruptParams",
+]

langchain_dev_utils/tool_calling/human_in_the_loop.py

@@ -0,0 +1,284 @@
+from typing import Any, Callable, Optional, TypedDict, Union, overload
+
+from langchain_core.tools import BaseTool
+from langchain_core.tools import tool as create_tool
+from langgraph.types import interrupt
+
+
+class InterruptParams(TypedDict):
+    tool_call_name: str
+    tool_call_args: dict[str, Any]
+    tool: BaseTool
+
+
+HumanInterruptHandler = Callable[[InterruptParams], Any]
+
+
+@overload
+def human_in_the_loop(
+    func: Callable,
+) -> BaseTool:
+    """
+    Decorator for adding human-in-the-loop review to a synchronous tool function.
+
+    Usage: @human_in_the_loop
+    """
+    ...
+
+
+@overload
+def human_in_the_loop(
+    *,
+    handler: Optional[HumanInterruptHandler] = None,
+) -> Callable[[Callable], BaseTool]:
+    """
+    Decorator for adding human-in-the-loop review to a synchronous tool function with custom handler.
+
+    Usage: @human_in_the_loop(handler=custom_handler)
+    """
+    ...
+
+
+@overload
+def human_in_the_loop_async(
+    func: Callable,
+) -> BaseTool:
+    """
+    Decorator for adding human-in-the-loop review to an asynchronous tool function.
+
+    Usage: @human_in_the_loop_async
+    """
+    ...
+
+
+@overload
+def human_in_the_loop_async(
+    *,
+    handler: Optional[HumanInterruptHandler] = None,
+) -> Callable[[Callable], BaseTool]:
+    """
+    Decorator for adding human-in-the-loop review to an asynchronous tool function with custom handler.
+
+    Usage: @human_in_the_loop_async(handler=custom_handler)
+    """
+    ...
+
+
+def _get_human_in_the_loop_request(params: InterruptParams) -> dict[str, Any]:
+    return {
+        "action_request": {
+            "action": params["tool_call_name"],
+            "args": params["tool_call_args"],
+        },
+        "config": {
+            "allow_accept": True,
+            "allow_edit": True,
+            "allow_respond": True,
+        },
+        "description": f"Please review tool call: {params['tool_call_name']}",
+    }
+
+
+def default_handler(params: InterruptParams) -> Any:
+    request = _get_human_in_the_loop_request(params)
+    response = interrupt(request)
+
+    if response["type"] == "accept":
+        return params["tool"].invoke(params["tool_call_args"])
+    elif response["type"] == "edit":
+        updated_args = response["args"]
+        return params["tool"].invoke(updated_args)
+    elif response["type"] == "response":
+        return response["args"]
+    else:
+        raise ValueError(f"Unsupported interrupt response type: {response['type']}")
+
+
+async def default_handler_async(params: InterruptParams) -> Any:
+    request = _get_human_in_the_loop_request(params)
+    response = interrupt(request)
+
+    if response["type"] == "accept":
+        return await params["tool"].ainvoke(params["tool_call_args"])
+    elif response["type"] == "edit":
+        updated_args = response["args"]
+        return await params["tool"].ainvoke(updated_args)
+    elif response["type"] == "response":
+        return response["args"]
+    else:
+        raise ValueError(f"Unsupported interrupt response type: {response['type']}")
+
+
+def human_in_the_loop(
+    func: Optional[Callable] = None,
+    *,
+    handler: Optional[HumanInterruptHandler] = None,
+) -> Union[Callable[[Callable], BaseTool], BaseTool]:
+    """
+    A decorator that adds human-in-the-loop review support to a synchronous tool.
+
+    This decorator allows you to add human review functionality to tools, enabling
+    users to approve, edit, or reject tool invocations before they are executed.
+
+    Supports both syntaxes:
+        @human_in_the_loop
+        @human_in_the_loop(handler=fn)
+
+    Args:
+        func: The function to decorate. **Do not pass this directly.**
+        handler: Configuration for the human interrupt. If not provided, uses default_handler.
+
+    Returns:
+        If `func` is provided, returns the decorated BaseTool.
+        If `func` is None, returns a decorator that will decorate the target function.
+
+    Example:
+        # Basic usage with default handler:
+        >>> from langchain_dev_utils.tool_calling import human_in_the_loop
+        >>> from langchain_core.tools import tool
+        >>> import datetime
+        >>>
+        >>> @human_in_the_loop
+        >>> @tool
+        >>> def get_current_time() -> str:
+        ...     \"\"\"Get current timestamp\"\"\"
+        ...     return str(datetime.datetime.now().timestamp())
+
+        # Usage with custom handler:
+        >>> def custom_handler(params: InterruptParams) -> Any:
+        ...     response = interrupt(
+        ...        # Please add your custom interrupt response content here
+        ...     )
+        ...     if response["type"] == "accept":
+        ...         return params["tool"].invoke(params["tool_call_args"])
+        ...     elif response["type"] == "reject":
+        ...         return "User rejected this tool call"
+        ...     else:
+        ...         raise ValueError(f"Unsupported response type: {response['type']}")
+        >>>
+        >>> @human_in_the_loop(handler=custom_handler)
+        >>> @tool
+        >>> def sensitive_operation(data: str) -> str:
+        ...     \"\"\"Perform sensitive operation on data\"\"\"
+        ...     return f"Processed: {data}"
+    """
+
+    def decorator(target_func: Callable) -> BaseTool:
+        """The actual decorator that wraps the target function."""
+        if not isinstance(target_func, BaseTool):
+            tool_obj = create_tool(target_func)
+        else:
+            tool_obj = target_func
+
+        handler_func: HumanInterruptHandler = handler or default_handler
+
+        @create_tool(
+            tool_obj.name,
+            description=tool_obj.description,
+            args_schema=tool_obj.args_schema,
+        )
+        def tool_with_human_review(**tool_input: Any) -> Any:
+            return handler_func(
+                {
+                    "tool_call_name": tool_obj.name,
+                    "tool_call_args": tool_input,
+                    "tool": tool_obj,
+                }
+            )
+
+        return tool_with_human_review
+
+    if func is not None:
+        return decorator(func)
+    else:
+        return decorator
+
+
+def human_in_the_loop_async(
+    func: Optional[Callable] = None,
+    *,
+    handler: Optional[HumanInterruptHandler] = None,
+) -> Union[Callable[[Callable], BaseTool], BaseTool]:
+    """
+    A decorator that adds human-in-the-loop review support to an asynchronous tool.
+
+    This is the async version of human_in_the_loop. It allows you to add human review
+    functionality to async tools, enabling users to approve, edit, or reject tool
+    invocations before they are executed.
+
+    Supports both syntaxes:
+        @human_in_the_loop_async
+        @human_in_the_loop_async(handler=fn)
+
+    Args:
+        func: The function to decorate. **Do not pass this directly.**
+        handler: Configuration for the human interrupt. If not provided, uses default_handler_async.
+
+    Returns:
+        If `func` is provided, returns the decorated BaseTool.
+        If `func` is None, returns a decorator that will decorate the target function.
+
+    Example:
+        # Basic usage with default handler:
+        >>> from langchain_dev_utils.tool_calling import human_in_the_loop_async
+        >>> from langchain_core.tools import tool
+        >>> import asyncio
+        >>> import datetime
+        >>>
+        >>> @human_in_the_loop_async
+        >>> @tool
+        >>> async def async_get_current_time() -> str:
+        ...     \"\"\"Asynchronously get current timestamp\"\"\"
+        ...     await asyncio.sleep(1)
+        ...     return str(datetime.datetime.now().timestamp())
+
+        # Usage with custom handler:
+        >>> async def custom_handler(params: InterruptParams) -> Any:
+        ...     response = interrupt(
+        ...         ... # Please add your custom interrupt response content here
+        ...     )
+        ...     if response["type"] == "accept":
+        ...         return await params["tool"].ainvoke(params["tool_call_args"])
+        ...     elif response["type"] == "reject":
+        ...         return "User rejected this tool call"
+        ...     else:
+        ...         raise ValueError(f"Unsupported response type: {response['type']}")
+        >>> @human_in_the_loop_async(handler=custom_handler)
+        >>> @tool
+        >>> async def async_sensitive_operation(data: str) -> str:
+        ...     \"\"\"Perform sensitive async operation on data\"\"\"
+        ...     await asyncio.sleep(0.1)  # Simulate async work
+        ...     return f"Processed: {data}"
+    """
+
+    def decorator(target_func: Callable) -> BaseTool:
+        """The actual decorator that wraps the target function."""
+        if not isinstance(target_func, BaseTool):
+            tool_obj = create_tool(target_func)
+        else:
+            tool_obj = target_func
+
+        handler_func: HumanInterruptHandler = handler or default_handler_async
+
+        @create_tool(
+            tool_obj.name,
+            description=tool_obj.description,
+            args_schema=tool_obj.args_schema,
+        )
+        async def atool_with_human_review(
+            **tool_input: Any,
+        ) -> Any:
+            return await handler_func(
+                {
+                    "tool_call_name": tool_obj.name,
+                    "tool_call_args": tool_input,
+                    "tool": tool_obj,
+                }
+            )
+
+        return atool_with_human_review
+
+    if func is not None:
+        return decorator(func)
+    else:
+        return decorator

langchain_dev_utils/tool_calling/utils.py

@@ -0,0 +1,81 @@
+from typing import Union
+
+from langchain_core.messages import AIMessage
+
+
+def has_tool_calling(message: AIMessage) -> bool:
+    """Check if a message contains tool calls.
+
+    This function determines whether an AI message contains tool calls,
+    which is useful for routing messages to appropriate handlers.
+
+    Args:
+        message: Any message type to check for tool calls
+
+    Returns:
+        bool: True if message is an AIMessage with tool calls, False otherwise
+
+    Example:
+        # Check for tool calls in response:
+        >>> from langchain_dev_utils.tool_calling import has_tool_calling, parse_tool_calling
+        >>> response = model.invoke("What time is it now?")
+        >>> if has_tool_calling(response):
+        ...     print("Tool calls found in response")
+    """
+
+    if any([block for block in message.content_blocks if block["type"] == "tool_call"]):
+        return True
+    if (
+        isinstance(message, AIMessage)
+        and hasattr(message, "tool_calls")
+        and len(message.tool_calls) > 0
+    ):
+        return True
+    return False
+
+
+def parse_tool_calling(
+    message: AIMessage, first_tool_call_only: bool = False
+) -> Union[tuple[str, dict], list[tuple[str, dict]]]:
+    """Parse a tool call from a message.
+
+    This function extracts tool call information from an AI message, returning
+    either the first tool call or all tool calls depending on the parameter.
+
+    Args:
+        message: Any message type to parse for tool calls
+        first_tool_call_only: If True, only the first tool call will be parsed
+
+    Returns:
+        Union[tuple[str, dict], list[tuple[str, dict]]]: The tool call name and args
+
+    Example:
+        # Parse single tool call:
+        >>> from langchain_dev_utils.tool_calling import has_tool_calling, parse_tool_calling
+        >>> response = model.invoke("What time is it now?")
+        >>> response
+        >>> if has_tool_calling(response):
+        ...     tool_name, tool_args = parse_tool_calling(response, first_tool_call_only=True)
+
+        # Parse multiple tool calls:
+        >>> if has_tool_calling(response):
+        ...     tool_calls = parse_tool_calling(response)
+    """
+
+    tool_calls = None
+
+    tool_call_blocks = [
+        block for block in message.content_blocks if block["type"] == "tool_call"
+    ]
+    if tool_call_blocks:
+        tool_calls = tool_call_blocks
+
+    if not tool_calls:
+        tool_calls = message.tool_calls
+
+    if not tool_calls:
+        raise ValueError("No tool call found in message")
+
+    if first_tool_call_only:
+        return (tool_calls[0]["name"], tool_calls[0]["args"])
+    return [(tool_call["name"], tool_call["args"]) for tool_call in tool_calls]

langchain_dev_utils-1.3.7.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: langchain-dev-utils
+Version: 1.3.7
+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
+Project-URL: documentation, https://tbice123123.github.io/langchain-dev-utils
+Author-email: tiebingice <tiebingice123@outlook.com>
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: langchain-core>=1.2.5
+Requires-Dist: langchain>=1.2.0
+Requires-Dist: langgraph>=1.0.0
+Provides-Extra: standard
+Requires-Dist: json-repair>=0.53.1; extra == 'standard'
+Requires-Dist: langchain-openai; extra == 'standard'
+Description-Content-Type: text/markdown
+
+# 🦜️🧰 langchain-dev-utils
+
+<p align="center">
+    <em>🚀 High-efficiency toolkit designed for LangChain and LangGraph developers</em>
+</p>
+
+<p align="center">
+  📚 <a href="https://tbice123123.github.io/langchain-dev-utils/">English</a> • 
+  <a href="https://tbice123123.github.io/langchain-dev-utils/zh/">中文</a>
+</p>
+
+[![PyPI](https://img.shields.io/pypi/v/langchain-dev-utils.svg?color=%2334D058&label=pypi%20package)](https://pypi.org/project/langchain-dev-utils/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python](https://img.shields.io/badge/python-3.11|3.12|3.13|3.14-%2334D058)](https://www.python.org/downloads)
+[![Downloads](https://static.pepy.tech/badge/langchain-dev-utils/month)](https://pepy.tech/project/langchain-dev-utils)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue)](https://tbice123123.github.io/langchain-dev-utils)
+
+> This is the English version. For the Chinese version, please visit [中文版本](https://github.com/TBice123123/langchain-dev-utils/blob/master/README_cn.md)
+
+## ✨ Why choose langchain-dev-utils?
+
+Tired of writing repetitive code in LangChain development? `langchain-dev-utils` is the solution you need! This lightweight yet powerful toolkit is designed to enhance the development experience of LangChain and LangGraph, helping you:
+
+- ⚡ **Boost development efficiency** - Reduce boilerplate code, allowing you to focus on core functionality
+- 🧩 **Simplify complex workflows** - Easily manage multi-model, multi-tool, and multi-agent applications
+- 🔧 **Enhance code quality** - Improve consistency and readability, reducing maintenance costs
+- 🎯 **Accelerate prototype development** - Quickly implement ideas, iterate and validate faster
+
+
+## 🎯 Core Features
+
+- **🔌 Unified model management** - Specify model providers through strings, easily switch and combine different models
+- **💬 Flexible message handling** - Support for chain-of-thought concatenation, streaming processing, and message formatting
+- **🛠️ Powerful tool calling** - Built-in tool call detection, parameter parsing, and human review functionality
+- **🤖 Efficient Agent development** - Simplify agent creation process, expand more common middleware
+- **📊 Flexible state graph composition** - Support for serial and parallel composition of multiple StateGraphs
+
+## ⚡ Quick Start
+
+**1. Install `langchain-dev-utils`**
+
+```bash
+pip install -U "langchain-dev-utils[standard]"
+```
+
+**2. Start using**
+
+```python
+from langchain.tools import tool
+from langchain_core.messages import HumanMessage
+from langchain_dev_utils.chat_models import register_model_provider, load_chat_model
+from langchain_dev_utils.agents import create_agent
+
+# Register model provider
+register_model_provider("vllm", "openai-compatible", base_url="http://localhost:8000/v1")
+
+@tool
+def get_current_weather(location: str) -> str:
+    """Get the current weather for the specified location"""
+    return f"25 degrees, {location}"
+
+# Dynamically load model using string
+model = load_chat_model("vllm:qwen3-4b")
+response = model.invoke("Hello")
+print(response)
+
+# Create agent
+agent = create_agent("vllm:qwen3-4b", tools=[get_current_weather])
+response = agent.invoke({"messages": [HumanMessage(content="What's the weather like in New York today?")]})
+print(response)
+```
+
+**For more features of this library, please visit the [full documentation](https://tbice123123.github.io/langchain-dev-utils/)**
+
+
+## 🛠️ GitHub Repository
+
+Visit the [GitHub repository](https://github.com/TBice123123/langchain-dev-utils) to view the source code and report issues.
+
+---
+
+<div align="center">
+  <p>Developed with ❤️ and ☕</p>
+  <p>If this project helps you, please give us a ⭐️</p>
+</div>

langchain_dev_utils-1.3.7.dist-info/RECORD

@@ -0,0 +1,44 @@
+langchain_dev_utils/__init__.py,sha256=_mC35C1yWAueGFOoiHyTIrBPPJjSh3G1KA8Ela0nE_w,23
+langchain_dev_utils/_utils.py,sha256=hWuxzxIlCPkT02xglWqkRnroky2mCmW5qtK-zHDH4RY,4032
+langchain_dev_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=Tw6KYMdZ5ESsWVjoImZimZI2Eg5rEipsqUVJ0tSVbUw,11536
+langchain_dev_utils/agents/middleware/__init__.py,sha256=QVQibaNHvHPyNTZ2UNFfYL153ZboaCHcoioTHK0FsiY,710
+langchain_dev_utils/agents/middleware/format_prompt.py,sha256=yIkoSVPp0FemkjezvGsOmtgOkZDyEYQ8yh4YWYYGtVc,2343
+langchain_dev_utils/agents/middleware/handoffs.py,sha256=rSkNXxqtjB8_xT0HUdxnKbchgY76BuTPX-Zc69H-_wI,7687
+langchain_dev_utils/agents/middleware/model_fallback.py,sha256=8xiNjTJ0yiRkPLCRfAGNnqY1TLstj1Anmiqyv5w2mA8,1633
+langchain_dev_utils/agents/middleware/model_router.py,sha256=IidYq72tPLa053gEg5IQpPzDzyCxYYEvpgT1K4qBwXw,7862
+langchain_dev_utils/agents/middleware/plan.py,sha256=Zz0dh1BRbsVgROmhjH2IIqylSsuKHZXJx0iztMBm8EU,14719
+langchain_dev_utils/agents/middleware/summarization.py,sha256=IoZ2PM1OC3AXwf0DWpfreuPOAipeiYu0KPmAABWXuY0,3087
+langchain_dev_utils/agents/middleware/tool_call_repair.py,sha256=oZF0Oejemqs9kSn8xbW79FWyVVarL4IGCz0gpqYBkFM,3529
+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=G_SNvd53ogho-LRgD7DCD65xj51J2JxmOkA4URNW6ZQ,11560
+langchain_dev_utils/chat_models/types.py,sha256=MD3cv_ZIe9fCdgwisNfuxAOhy-j4YSs1ZOQYyCjlNKs,927
+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=Xsd6HN1zGGDl87bZ5NMfwKfxWkgdP4DpszEqlb4Z-MY,27198
+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=GXFKZSAExMtCFUpsd6mY4NxCWCrq7JAatBw3kS9LaKY,8803
+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=fo7-m7dcWL4xrhSqdAHHVREsiXfVOvIrlaotaYTEiyE,3159
+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=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
+langchain_dev_utils/pipeline/types.py,sha256=T3aROKKXeWvd0jcH5XkgMDQfEkLfPaiOhhV2q58fDHs,112
+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.7.dist-info/METADATA,sha256=bleCSa7JHZ_1zYiYT-qYKnRSnFf5yU7eKX-nTWja9rw,4552
+langchain_dev_utils-1.3.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langchain_dev_utils-1.3.7.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
+langchain_dev_utils-1.3.7.dist-info/RECORD,,

langchain_dev_utils-1.3.7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

langchain_dev_utils-1.3.7.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tbice 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.