hyperpocket-langgraph 0.0.1__py3-none-any.whl

hyperpocket_langgraph/__init__.py

@@ -0,0 +1,3 @@
+from hyperpocket_langgraph.pocket_langgraph import PocketLanggraph
+
+__all__ = ["PocketLanggraph"]

hyperpocket_langgraph/pocket_langgraph.py

@@ -0,0 +1,221 @@
+import copy
+from typing import List, Any
+
+from langchain_core.runnables import RunnableConfig
+from langgraph.errors import NodeInterrupt
+from pydantic import BaseModel
+
+from hyperpocket.config import pocket_logger
+from hyperpocket.pocket_main import ToolLike
+from hyperpocket.prompts import pocket_extended_tool_description
+from hyperpocket.server.server import PocketServerOperations
+
+try:
+    from langchain_core.messages import AnyMessage, ToolMessage, AIMessage, RemoveMessage, SystemMessage
+    from langchain_core.tools import BaseTool, StructuredTool
+except ImportError:
+    raise ImportError(
+        "You need to install langchain to use pocket langgraph."
+    )
+
+try:
+    from langgraph.constants import START, END
+    from langgraph.graph import add_messages, StateGraph, MessagesState
+    from langgraph.graph.state import CompiledStateGraph
+except ImportError:
+    raise ImportError(
+        "You need to install langgraph to use pocket langgraph"
+    )
+
+from hyperpocket import Pocket, PocketAuth
+from hyperpocket.tool import Tool as PocketTool
+
+
+class PocketLanggraphBaseState(MessagesState):
+    pass
+
+
+class PocketLanggraph(Pocket):
+    langgraph_tools: dict[str, BaseTool]
+
+    def __init__(self,
+                 tools: List[ToolLike],
+                 auth: PocketAuth = None):
+        super().__init__(tools, auth)
+        self.langgraph_tools = {}
+        for tool_name, tool_impl in self.tools.items():
+            self.langgraph_tools[tool_name] = self._get_langgraph_tool(tool_impl)
+
+    def get_tools(self):
+        return [v for v in self.langgraph_tools.values()]
+
+    def get_tool_node(self, should_interrupt: bool = False):
+        async def _tool_node(state: PocketLanggraphBaseState, config: RunnableConfig) -> dict:
+            thread_id = config.get("configurable", {}).get("thread_id", "default")
+            last_message = state['messages'][-1]
+            tool_calls = last_message.tool_calls
+
+            # 01. prepare
+            prepare_list = []
+            prepare_done_list = []
+            need_prepare = False
+            for tool_call in tool_calls:
+                pocket_logger.debug(f"prepare tool {tool_call}")
+                _tool_call = copy.deepcopy(tool_call)
+
+                tool_call_id = _tool_call['id']
+                tool_name = _tool_call['name']
+                tool_args = _tool_call['args']
+                body = tool_args.pop('body')
+                if isinstance(body, BaseModel):
+                    body = body.model_dump()
+
+                prepare = await self.prepare_in_subprocess(tool_name, body=body, thread_id=thread_id,
+                                                           profile=tool_args.get("profile", "default"))
+                need_prepare |= True if prepare else False
+
+                if prepare is None:
+                    prepare_done_list.append(ToolMessage(content="prepare done", tool_call_id=tool_call_id))
+                else:
+                    prepare_list.append(ToolMessage(content=prepare, tool_call_id=tool_call_id))
+
+            if need_prepare:
+                pocket_logger.debug(f"need prepare : {prepare_list}")
+                if should_interrupt:  # interrupt
+                    pocket_logger.debug(f"{last_message.name}({last_message.id}) is interrupt.")
+                    result = "\n\t" + "\n\t".join(set(msg.content for msg in prepare_list))
+                    raise NodeInterrupt(f'{result}\n\nThe tool execution interrupted. Please talk to me to resume.')
+
+                else:  # multi turn
+                    pocket_logger.debug(f"{last_message.name}({last_message.id}) is multi-turn")
+                    return {"messages": prepare_done_list + prepare_list}
+
+            pocket_logger.debug(f"no need prepare {last_message.name}({last_message.id})")
+
+            # 02. authenticate and tool call
+            tool_messages = []
+            for tool_call in tool_calls:
+                pocket_logger.debug(f"authenticate and call {tool_call}")
+                _tool_call = copy.deepcopy(tool_call)
+
+                tool_call_id = _tool_call['id']
+                tool_name = _tool_call['name']
+                tool_args = _tool_call['args']
+                body = tool_args.pop('body')
+                if isinstance(body, BaseModel):
+                    body = body.model_dump()
+
+                try:
+                    auth = await self.authenticate_in_subprocess(
+                        tool_name, body=body, thread_id=thread_id, profile=tool_args.get("profile", "default"))
+                except Exception as e:
+                    pocket_logger.error(f"occur exception during authenticate. error : {e}")
+                    tool_messages.append(
+                        ToolMessage(content=f"occur exception during authenticate. error : {e}", tool_name=tool_name,
+                                    tool_call_id=tool_call_id))
+                    continue
+
+                try:
+                    result = await self.tool_call_in_subprocess(
+                        tool_name, body=body, envs=auth, thread_id=thread_id,
+                        profile=tool_args.get("profile", "default"))
+                except Exception as e:
+                    pocket_logger.error(f"occur exception during tool calling. error : {e}")
+                    tool_messages.append(
+                        ToolMessage(content=f"occur exception during tool calling. error : {e}", tool_name=tool_name,
+                                    tool_call_id=tool_call_id))
+                    continue
+
+                pocket_logger.debug(f"{tool_name} tool result : {result}")
+                tool_messages.append(ToolMessage(content=result, tool_name=tool_name, tool_call_id=tool_call_id))
+
+            return {"messages": tool_messages}
+
+        return _tool_node
+
+    async def prepare_in_subprocess(self,
+                                    tool_name: str,
+                                    body: Any,
+                                    thread_id: str = 'default',
+                                    profile: str = 'default',
+                                    *args, **kwargs):
+        prepare = await self.server.call_in_subprocess(
+            PocketServerOperations.PREPARE_AUTH,
+            args,
+            {
+                'tool_name': tool_name,
+                'body': body,
+                'thread_id': thread_id,
+                'profile': profile,
+                **kwargs,
+            },
+        )
+
+        return prepare
+
+    async def authenticate_in_subprocess(self,
+                                         tool_name: str,
+                                         body: Any,
+                                         thread_id: str = 'default',
+                                         profile: str = 'default',
+                                         *args, **kwargs):
+        credentials = await self.server.call_in_subprocess(
+            PocketServerOperations.AUTHENTICATE,
+            args,
+            {
+                'tool_name': tool_name,
+                'body': body,
+                'thread_id': thread_id,
+                'profile': profile,
+                **kwargs,
+            },
+        )
+
+        return credentials
+
+    async def tool_call_in_subprocess(self,
+                                      tool_name: str,
+                                      body: Any,
+                                      thread_id: str = 'default',
+                                      profile: str = 'default',
+                                      *args, **kwargs):
+        result = await self.server.call_in_subprocess(
+            PocketServerOperations.TOOL_CALL,
+            args,
+            {
+                'tool_name': tool_name,
+                'body': body,
+                'thread_id': thread_id,
+                'profile': profile,
+                **kwargs,
+            },
+        )
+
+        return result
+
+    def _get_langgraph_tool(self, pocket_tool: PocketTool) -> BaseTool:
+        def _invoke(body: Any, thread_id: str = 'default', profile: str = 'default', **kwargs) -> str:
+            if isinstance(body, BaseModel):
+                body = body.model_dump()
+            result, interrupted = self.invoke_with_state(pocket_tool.name, body, thread_id, profile, **kwargs)
+            say = result
+            if interrupted:
+                say = f'{say}\n\nThe tool execution interrupted. Please talk to me to resume.'
+            return say
+
+        async def _ainvoke(body: Any, thread_id: str = 'default', profile: str = 'default', **kwargs) -> str:
+            if isinstance(body, BaseModel):
+                body = body.model_dump()
+            result, interrupted = await self.ainvoke_with_state(pocket_tool.name, body, thread_id, profile, **kwargs)
+            say = result
+            if interrupted:
+                say = f'{say}\n\nThe tool execution interrupted. Please talk to me to resume.'
+            return say
+
+        return StructuredTool.from_function(
+            func=_invoke,
+            coroutine=_ainvoke,
+            name=pocket_tool.name,
+            description=pocket_extended_tool_description(pocket_tool.description),
+            args_schema=pocket_tool.schema_model(),
+        )

hyperpocket_langgraph-0.0.1.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.1
+Name: hyperpocket-langgraph
+Version: 0.0.1
+Summary: 
+Author: moon
+Author-email: moon@vessl.ai
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: hyperpocket (==0.0.3)
+Requires-Dist: langgraph (>=0.2.59,<0.3.0)
+Description-Content-Type: text/markdown
+
+# Langgraph extensions
+
+- Provide compatible tools in LangGraph
+- Offer various methods for controlling authentication flow
+    - [Multi-turn](#multi-turn)
+    - [Human-in-the-loop](#human-in-the-loop-auth)
+
+## Get Pocket Subgraph
+
+```python
+import hyperpocket as pk
+from pocket_langgraph import PocketLanggraph
+
+pocket = PocketLanggraph(tools=[
+  *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+  *pk.curated_tools.LINEAR,
+  "https://github.com/my-org/some-awesome-tool",
+])
+
+# get tool node from pocket
+pocket_node = pocket.get_tool_node()
+```
+
+## Binding Pocket Tools
+
+```python
+import os
+
+from langchain_openai import ChatOpenAI
+
+import hyperpocket as pk
+from pocket_langgraph import PocketLanggraph
+
+pocket = PocketLanggraph(tools=[
+  *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+  *pk.curated_tools.LINEAR,
+  "https://github.com/my-org/some-awesome-tool",
+])
+
+# get tools from pocket to bind llm
+tools = pocket.get_tools()
+llm = ChatOpenAI(model="gpt-4o", api_key=os.getenv("OPENAI_API_KEY"))
+
+# bind pocket tools with llm
+llm_with_tools = llm.bind_tools(tools)
+```
+
+## Examples
+
+```python
+import os
+from typing import Annotated
+
+from langchain_core.runnables import RunnableConfig
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import tools_condition
+from typing_extensions import TypedDict
+
+import hyperpocket as pk
+from pocket_langgraph import PocketLanggraph
+
+# Define pocket tools
+pocket = PocketLanggraph(tools=[
+  *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+  *pk.curated_tools.LINEAR,
+  "https://github.com/my-org/some-awesome-tool",
+])
+
+# Get Pocket ToolNode
+pocket_node = pocket.get_tool_node()
+
+
+# Define your own langgraph state
+class State(TypedDict):
+  messages: Annotated[list, add_messages]
+
+
+# Biding Pocket Tools
+tools = pocket.get_tools()
+llm = ChatOpenAI(model="gpt-4o", api_key=os.getenv("OPENAI_API_KEY"))
+llm_with_tools = llm.bind_tools(tools)
+
+
+# Make your langgraph with pocket nodes and bound llm
+def chatbot(state: State):
+  return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+
+graph_builder = StateGraph(State)
+graph_builder.add_node("chatbot", chatbot)
+
+# add pocket tool node
+graph_builder.add_node("tools", pocket_node)
+
+graph_builder.add_conditional_edges(
+  "chatbot",
+  tools_condition,
+)
+
+graph_builder.add_edge("tools", "chatbot")
+graph_builder.add_edge(START, "chatbot")
+graph_builder.add_edge("chatbot", END)
+
+memory = MemorySaver()
+graph = graph_builder.compile(checkpointer=memory)
+config = RunnableConfig(
+  recursion_limit=30,
+  configurable={"thread_id": "1"},  # edit thread_id by user if needed
+)
+```
+
+## Authentication Flow Control
+
+In Pocket, you can configure whether authentication operates in a multi-turn manner or as human-in-the-loop
+
+by setting the `should_interrupt` flag when calling `get_tool_node`
+
+### Multi-turn
+
+Perform authentication in a multi-turn way
+
+```python
+import hyperpocket as pk
+from pocket_langgraph import PocketLanggraph
+
+# Define pocket tools
+pocket = PocketLanggraph(tools=[
+  *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+  *pk.curated_tools.LINEAR,
+  "https://github.com/my-org/some-awesome-tool",
+])
+
+# Get Pocket ToolNode
+pocket_node = pocket.get_tool_node(should_interrupt=False)  # multi turn 
+```
+
+### Human-in-the-loop Auth
+
+```python
+import hyperpocket as pk
+from pocket_langgraph import PocketLanggraph
+
+# Define pocket tools
+pocket = PocketLanggraph(tools=[
+  *pk.curated_tools.SLACK,  # SLACK = [slack_get_message, slack_post_message, ..]
+  *pk.curated_tools.LINEAR,
+  "https://github.com/my-org/some-awesome-tool",
+])
+
+# Get Pocket ToolNode
+pocket_node = pocket.get_tool_node(should_interrupt=True)  # Human-in-the-loop 
+```
+
+### Differences between multi-turn and human-in-the-loop
+
+The two approaches may not differ significantly in terms of user experience, but they are fundamentally distinct
+internally.
+
+In the case of the **multi-turn** way, the decision to return to an ongoing authentication(auth) flow is delegated to
+the agent.
+
+As a result, if the user want to cancel or modify the auth process midway, then **agent can adapt the
+auth flow to incorporate those changes.**
+
+<br>
+However, with the human-in-the-loop way, it simply resumes from an interrupted point, proceeding directly with the
+previous flow regardless of user input.
+
+(Currently, users need to manually provide any input to move forward, but future updates aim to automate this transition
+once the user's task is complete.)
+
+Therefore, **in the human-in-the-loop way, users cannot modify or cancel the auth flow once it's resumed.**
+
+<br>
+
+
+That said, the multi-turn approach has its drawbacks as well. Since the agent determines whether to re-enter the auth
+flow, there is a risk of incorrect decisions being made.
+
+Conversely, the human-in-the-loop approach eliminates this risk by always continuing the previous flow as it is,
+offering more predictable and controlled behavior for managing the auth flow.
+
+

hyperpocket_langgraph-0.0.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+hyperpocket_langgraph/__init__.py,sha256=0Az6FKsAvohOk8G4kUE99g6kyWz-Nf7dUuCuN3_pViY,97
+hyperpocket_langgraph/pocket_langgraph.py,sha256=SqXZDdqvOKX66f0rRI8Ol-rNkL66yIXLFlToyorMvMs,9176
+hyperpocket_langgraph-0.0.1.dist-info/METADATA,sha256=9zG8UMulVdv3cVcSMHiOXzauJov9Jldx44myu1PRQeg,5671
+hyperpocket_langgraph-0.0.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+hyperpocket_langgraph-0.0.1.dist-info/RECORD,,

hyperpocket_langgraph-0.0.1.dist-info/WHEEL

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