hyperpocket-langgraph 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

hyperpocket_langgraph/__init__.py

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

hyperpocket_langgraph/pocket_langgraph.py

@@ -1,26 +1,21 @@
 import copy
 from typing import Optional
 
+from hyperpocket.config import pocket_logger
 from langchain_core.runnables import RunnableConfig
 from langgraph.errors import NodeInterrupt
 from pydantic import BaseModel
 
-from hyperpocket.config import pocket_logger
-
 try:
     from langchain_core.messages import ToolMessage
     from langchain_core.tools import BaseTool, StructuredTool
 except ImportError:
-    raise ImportError(
-        "You need to install langchain to use pocket langgraph."
-    )
+    raise ImportError("You need to install langchain to use pocket langgraph.")
 
 try:
     from langgraph.graph import MessagesState
 except ImportError:
-    raise ImportError(
-        "You need to install langgraph to use pocket langgraph"
-    )
+    raise ImportError("You need to install langgraph to use pocket langgraph")
 
 from hyperpocket import Pocket
 from hyperpocket.tool import Tool as PocketTool
@@ -34,16 +29,22 @@ class PocketLanggraph(Pocket):
     def get_tools(self, use_profile: Optional[bool] = None):
         if use_profile is not None:
             self.use_profile = use_profile
-        return [self._get_langgraph_tool(tool_impl) for tool_impl in
-                self.core.tools.values()]
-
-    def get_tool_node(self, should_interrupt: bool = False, use_profile: Optional[bool] = None):
+        return [
+            self._get_langgraph_tool(tool_impl)
+            for tool_impl in self.core.tools.values()
+        ]
+
+    def get_tool_node(
+        self, should_interrupt: bool = False, use_profile: Optional[bool] = None
+    ):
         if use_profile is not None:
             self.use_profile = use_profile
 
-        async def _tool_node(state: PocketLanggraphBaseState, config: RunnableConfig) -> dict:
+        async def _tool_node(
+            state: PocketLanggraphBaseState, config: RunnableConfig
+        ) -> dict:
             thread_id = config.get("configurable", {}).get("thread_id", "default")
-            last_message = state['messages'][-1]
+            last_message = state["messages"][-1]
             tool_calls = last_message.tool_calls
 
             # 01. prepare
@@ -54,9 +55,9 @@ class PocketLanggraph(Pocket):
                 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']
+                tool_call_id = _tool_call["id"]
+                tool_name = _tool_call["name"]
+                tool_args = _tool_call["args"]
 
                 if self.use_profile:
                     body = tool_args.pop("body")
@@ -68,27 +69,42 @@ class PocketLanggraph(Pocket):
                 if isinstance(body, BaseModel):
                     body = body.model_dump()
 
-                prepare = await self.prepare_in_subprocess(tool_name, body=body, thread_id=thread_id,
-                                                           profile=profile)
+                prepare = await self.prepare_in_subprocess(
+                    tool_name, body=body, thread_id=thread_id, profile=profile
+                )
                 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))
+                    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))
+                    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.')
+                    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")
+                    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})")
+            pocket_logger.debug(
+                f"no need prepare {last_message.name}({last_message.id})"
+            )
 
             # 02. authenticate and tool call
             tool_messages = []
@@ -96,9 +112,9 @@ class PocketLanggraph(Pocket):
                 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']
+                tool_call_id = _tool_call["id"]
+                tool_name = _tool_call["name"]
+                tool_args = _tool_call["args"]
                 if self.use_profile:
                     body = tool_args.pop("body")
                     profile = tool_args.pop("profile", "default")
@@ -111,27 +127,48 @@ class PocketLanggraph(Pocket):
 
                 try:
                     auth = await self.authenticate_in_subprocess(
-                        tool_name, body=body, thread_id=thread_id, profile=profile)
+                        tool_name, body=body, thread_id=thread_id, profile=profile
+                    )
                 except Exception as e:
-                    pocket_logger.error(f"occur exception during authenticate. error : {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))
+                        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"))
+                        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}")
+                    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))
+                        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))
+                tool_messages.append(
+                    ToolMessage(
+                        content=result, tool_name=tool_name, tool_call_id=tool_call_id
+                    )
+                )
 
             return {"messages": tool_messages}
 
@@ -151,10 +188,12 @@ class PocketLanggraph(Pocket):
             if isinstance(body, BaseModel):
                 body = body.model_dump()
 
-            result, interrupted = self.invoke_with_state(pocket_tool.name, body, thread_id, profile, **kwargs)
+            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.'
+                say = f"{say}\n\nThe tool execution interrupted. Please talk to me to resume."
             return say
 
         async def _ainvoke(**kwargs) -> str:
@@ -170,10 +209,12 @@ class PocketLanggraph(Pocket):
             if isinstance(body, BaseModel):
                 body = body.model_dump()
 
-            result, interrupted = await self.ainvoke_with_state(pocket_tool.name, body, thread_id, profile, **kwargs)
+            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.'
+                say = f"{say}\n\nThe tool execution interrupted. Please talk to me to resume."
             return say
 
         return StructuredTool.from_function(

{hyperpocket_langgraph-0.1.10.dist-info → hyperpocket_langgraph-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperpocket-langgraph
-Version: 0.1.10
+Version: 0.2.0
 Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
 Requires-Python: >=3.10
 Requires-Dist: hyperpocket>=0.0.3

hyperpocket_langgraph-0.2.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+hyperpocket_langgraph/__init__.py,sha256=Zqzel_ezEkzYOwVuzYWTQr4SJ737dd9hALXrIpMywEo,98
+hyperpocket_langgraph/pocket_langgraph.py,sha256=Y1kj27T0NR7PFsO9NwQsZxBK9In-yQkwXTp_yDlPv80,8393
+hyperpocket_langgraph-0.2.0.dist-info/METADATA,sha256=zmKuKzy8eSMrKaDaiCi3bkkTM92OtX1NSyqyFBAZLmc,5409
+hyperpocket_langgraph-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperpocket_langgraph-0.2.0.dist-info/RECORD,,

hyperpocket_langgraph-0.1.10.dist-info/RECORD

@@ -1,5 +0,0 @@
-hyperpocket_langgraph/__init__.py,sha256=0Az6FKsAvohOk8G4kUE99g6kyWz-Nf7dUuCuN3_pViY,97
-hyperpocket_langgraph/pocket_langgraph.py,sha256=y8GT64UrcriVr36gAf5NbTSFfnefl3NrcGnzFKqz6qY,7540
-hyperpocket_langgraph-0.1.10.dist-info/METADATA,sha256=EYoaPzvSBQ884u5LLA6iBwaJRb4QuDAYX6v8bl2VyWE,5410
-hyperpocket_langgraph-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperpocket_langgraph-0.1.10.dist-info/RECORD,,