goose-py 0.10.1__py3-none-any.whl → 0.10.2__py3-none-any.whl

goose/_internal/agent.py

@@ -5,12 +5,11 @@ from typing import Any, Literal, Protocol, overload
 from litellm import acompletion
 from pydantic import ValidationError
 
+from goose._internal.result import FindReplaceResponse, Result, TextResult
+from goose._internal.types.agent import AIModel, AssistantMessage, SystemMessage, UserMessage
 from goose._internal.types.telemetry import AgentResponse
 from goose.errors import Honk
 
-from .result import FindReplaceResponse, Result, TextResult
-from .types.agent import AIModel, LLMMessage
-
 
 class IAgentLogger(Protocol):
     async def __call__(self, *, response: AgentResponse[Any]) -> None: ...
@@ -31,23 +30,27 @@ class Agent:
     async def generate[R: Result](
         self,
         *,
-        messages: list[LLMMessage],
+        messages: list[UserMessage | AssistantMessage],
         model: AIModel,
         task_name: str,
         response_model: type[R] = TextResult,
-        system: LLMMessage | None = None,
+        system: SystemMessage | None = None,
     ) -> R:
-        start_time = datetime.now()
-        if system is not None:
-            messages.insert(0, system)
+        rendered_messages = [message.render() for message in messages]
+        rendered_system = system.render() if system is not None else None
+
+        completion_messages = (
+            [rendered_system] + rendered_messages if rendered_system is not None else rendered_messages
+        )
 
+        start_time = datetime.now()
         if response_model is TextResult:
-            response = await acompletion(model=model.value, messages=messages)
+            response = await acompletion(model=model.value, messages=completion_messages)
             parsed_response = response_model.model_validate({"text": response.choices[0].message.content})
         else:
             response = await acompletion(
                 model=model.value,
-                messages=messages,
+                messages=completion_messages,
                 response_format=response_model,
             )
             parsed_response = response_model.model_validate_json(response.choices[0].message.content)
@@ -59,8 +62,8 @@ class Agent:
             flow_name=self.flow_name,
             task_name=task_name,
             model=model,
-            system=system,
-            input_messages=messages,
+            system=rendered_system,
+            input_messages=rendered_messages,
             input_tokens=response.usage.prompt_tokens,
             output_tokens=response.usage.completion_tokens,
             start_time=start_time,
@@ -75,13 +78,22 @@ class Agent:
         return parsed_response
 
     async def ask(
-        self, *, messages: list[LLMMessage], model: AIModel, task_name: str, system: LLMMessage | None = None
+        self,
+        *,
+        messages: list[UserMessage | AssistantMessage],
+        model: AIModel,
+        task_name: str,
+        system: SystemMessage | None = None,
     ) -> str:
-        start_time = datetime.now()
+        rendered_messages = [message.render() for message in messages]
+        rendered_system = system.render() if system is not None else None
+
+        completion_messages = (
+            [rendered_system] + rendered_messages if rendered_system is not None else rendered_messages
+        )
 
-        if system is not None:
-            messages.insert(0, system)
-        response = await acompletion(model=model.value, messages=messages)
+        start_time = datetime.now()
+        response = await acompletion(model=model.value, messages=completion_messages)
 
         end_time = datetime.now()
         agent_response = AgentResponse(
@@ -90,8 +102,8 @@ class Agent:
             flow_name=self.flow_name,
             task_name=task_name,
             model=model,
-            system=system,
-            input_messages=messages,
+            system=rendered_system,
+            input_messages=rendered_messages,
             input_tokens=response.usage.prompt_tokens,
             output_tokens=response.usage.completion_tokens,
             start_time=start_time,
@@ -108,19 +120,23 @@ class Agent:
     async def refine[R: Result](
         self,
         *,
-        messages: list[LLMMessage],
+        messages: list[UserMessage | AssistantMessage],
         model: AIModel,
         task_name: str,
         response_model: type[R],
-        system: LLMMessage | None = None,
+        system: SystemMessage | None = None,
     ) -> R:
         start_time = datetime.now()
 
-        if system is not None:
-            messages.insert(0, system)
+        rendered_messages = [message.render() for message in messages]
+        rendered_system = system.render() if system is not None else None
+
+        completion_messages = (
+            [rendered_system] + rendered_messages if rendered_system is not None else rendered_messages
+        )
 
         find_replace_response = await acompletion(
-            model=model.value, messages=messages, response_format=FindReplaceResponse
+            model=model.value, messages=completion_messages, response_format=FindReplaceResponse
         )
         parsed_find_replace_response = FindReplaceResponse.model_validate_json(
             find_replace_response.choices[0].message.content
@@ -133,8 +149,8 @@ class Agent:
             flow_name=self.flow_name,
             task_name=task_name,
             model=model,
-            system=system,
-            input_messages=messages,
+            system=rendered_system,
+            input_messages=rendered_messages,
             input_tokens=find_replace_response.usage.prompt_tokens,
             output_tokens=find_replace_response.usage.completion_tokens,
             start_time=start_time,
@@ -158,58 +174,58 @@ class Agent:
     async def __call__[R: Result](
         self,
         *,
-        messages: list[LLMMessage],
+        messages: list[UserMessage | AssistantMessage],
         model: AIModel,
         task_name: str,
         mode: Literal["generate"],
         response_model: type[R],
-        system: LLMMessage | None = None,
+        system: SystemMessage | None = None,
     ) -> R: ...
 
     @overload
     async def __call__[R: Result](
         self,
         *,
-        messages: list[LLMMessage],
+        messages: list[UserMessage | AssistantMessage],
         model: AIModel,
         task_name: str,
         mode: Literal["ask"],
         response_model: type[R] = TextResult,
-        system: LLMMessage | None = None,
+        system: SystemMessage | None = None,
     ) -> str: ...
 
     @overload
     async def __call__[R: Result](
         self,
         *,
-        messages: list[LLMMessage],
+        messages: list[UserMessage | AssistantMessage],
         model: AIModel,
         task_name: str,
         response_model: type[R],
         mode: Literal["refine"],
-        system: LLMMessage | None = None,
+        system: SystemMessage | None = None,
     ) -> R: ...
 
     @overload
     async def __call__[R: Result](
         self,
         *,
-        messages: list[LLMMessage],
+        messages: list[UserMessage | AssistantMessage],
         model: AIModel,
         task_name: str,
         response_model: type[R],
-        system: LLMMessage | None = None,
+        system: SystemMessage | None = None,
     ) -> R: ...
 
     async def __call__[R: Result](
         self,
         *,
-        messages: list[LLMMessage],
+        messages: list[UserMessage | AssistantMessage],
         model: AIModel,
         task_name: str,
         response_model: type[R] = TextResult,
         mode: Literal["generate", "ask", "refine"] = "generate",
-        system: LLMMessage | None = None,
+        system: SystemMessage | None = None,
     ) -> R | str:
         match mode:
             case "generate":
@@ -232,13 +248,13 @@ class Agent:
 
         return response_model.model_validate_json(dumped_result)
 
-    def __find_last_result[R: Result](self, *, messages: list[LLMMessage], response_model: type[R]) -> R:
+    def __find_last_result[R: Result](
+        self, *, messages: list[UserMessage | AssistantMessage], response_model: type[R]
+    ) -> R:
         for message in reversed(messages):
-            if message["role"] == "assistant":
+            if isinstance(message, AssistantMessage):
                 try:
-                    only_part = message["content"][0]
-                    if only_part["type"] == "text":
-                        return response_model.model_validate_json(only_part["text"])
+                    return response_model.model_validate_json(message.text)
                 except ValidationError:
                     continue
 

goose/_internal/conversation.py

@@ -2,11 +2,10 @@ from typing import Self
 
 from pydantic import BaseModel
 
+from goose._internal.result import Result
+from goose._internal.types.agent import AssistantMessage, SystemMessage, UserMessage
 from goose.errors import Honk
 
-from .result import Result
-from .types.agent import AssistantMessage, LLMMessage, SystemMessage, UserMessage
-
 
 class Conversation[R: Result](BaseModel):
     user_messages: list[UserMessage]
@@ -17,26 +16,23 @@ class Conversation[R: Result](BaseModel):
     def awaiting_response(self) -> bool:
         return len(self.user_messages) == len(self.assistant_messages)
 
-    def render(self) -> list[LLMMessage]:
-        messages: list[LLMMessage] = []
-        if self.context is not None:
-            messages.append(self.context.render())
-
+    def get_messages(self) -> list[UserMessage | AssistantMessage]:
+        messages: list[UserMessage | AssistantMessage] = []
         for message_index in range(len(self.user_messages)):
             message = self.assistant_messages[message_index]
             if isinstance(message, str):
-                messages.append(AssistantMessage(text=message).render())
+                messages.append(AssistantMessage(text=message))
             else:
-                messages.append(AssistantMessage(text=message.model_dump_json()).render())
+                messages.append(AssistantMessage(text=message.model_dump_json()))
 
-            messages.append(self.user_messages[message_index].render())
+            messages.append(self.user_messages[message_index])
 
         if len(self.assistant_messages) > len(self.user_messages):
             message = self.assistant_messages[-1]
             if isinstance(message, str):
-                messages.append(AssistantMessage(text=message).render())
+                messages.append(AssistantMessage(text=message))
             else:
-                messages.append(AssistantMessage(text=message.model_dump_json()).render())
+                messages.append(AssistantMessage(text=message.model_dump_json()))
 
         return messages
 

goose/_internal/flow.py

@@ -3,12 +3,12 @@ from contextlib import asynccontextmanager
 from types import CodeType
 from typing import Protocol, overload
 
-from ..errors import Honk
-from .agent import Agent, IAgentLogger
-from .conversation import Conversation
-from .result import Result
-from .state import FlowArguments, FlowRun, get_current_flow_run, set_current_flow_run
-from .store import IFlowRunStore, InMemoryFlowRunStore
+from goose._internal.agent import Agent, IAgentLogger
+from goose._internal.conversation import Conversation
+from goose._internal.result import Result
+from goose._internal.state import FlowArguments, FlowRun, get_current_flow_run, set_current_flow_run
+from goose._internal.store import IFlowRunStore, InMemoryFlowRunStore
+from goose.errors import Honk
 
 
 class IGenerator[FlowArgumentsT: FlowArguments](Protocol):

goose/_internal/store.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Protocol
 
-from .state import SerializedFlowRun
+from goose._internal.state import SerializedFlowRun
 
 
 class IFlowRunStore(Protocol):

goose/_internal/task.py

@@ -4,11 +4,11 @@ from typing import Any, overload
 
 from pydantic import BaseModel
 
-from ..errors import Honk
-from .agent import Agent, AIModel
-from .result import Result
-from .state import FlowRun, NodeState, get_current_flow_run
-from .types.agent import SystemMessage, UserMessage
+from goose._internal.agent import Agent, AIModel
+from goose._internal.result import Result
+from goose._internal.state import FlowRun, NodeState, get_current_flow_run
+from goose._internal.types.agent import SystemMessage, UserMessage
+from goose.errors import Honk
 
 
 class Task[**P, R: Result]:
@@ -53,10 +53,10 @@ class Task[**P, R: Result]:
 
         node_state.add_user_message(message=user_message)
         answer = await flow_run.agent(
-            messages=node_state.conversation.render(),
+            messages=node_state.conversation.get_messages(),
             model=self._refinement_model,
             task_name=f"ask--{self.name}",
-            system=context.render() if context is not None else None,
+            system=context,
             mode="ask",
         )
         node_state.add_answer(answer=answer)
@@ -82,10 +82,10 @@ class Task[**P, R: Result]:
         node_state.add_user_message(message=user_message)
 
         result = await flow_run.agent(
-            messages=node_state.conversation.render(),
+            messages=node_state.conversation.get_messages(),
             model=self._refinement_model,
             task_name=f"refine--{self.name}",
-            system=context.render() if context is not None else None,
+            system=context,
             response_model=self.result_type,
             mode="refine",
         )

{goose_py-0.10.1.dist-info → goose_py-0.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: goose-py
-Version: 0.10.1
+Version: 0.10.2
 Summary: A tool for AI workflows based on human-computer collaboration and structured output.
 Author-email: Nash Taylor <nash@chelle.ai>, Joshua Cook <joshua@chelle.ai>, Michael Sankur <michael@chelle.ai>
 Requires-Python: >=3.12

{goose_py-0.10.1.dist-info → goose_py-0.10.2.dist-info}/RECORD

@@ -5,16 +5,16 @@ goose/flow.py,sha256=YsZLBa5I1W27_P6LYGWbtFX8ZYx9vJG3KtENYChHm5E,111
 goose/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 goose/runs.py,sha256=ub-r_gzbUbaIzWXX-jc-dncNxEh6zTfzIkmnDfCSbRI,160
 goose/task.py,sha256=95rspdxETJoY12IHBl3KjnVIdqQnf1jDKlnGWNWOTvQ,53
-goose/_internal/agent.py,sha256=v_nzQLM_vyKWOc-g1Ke8TwlThkThjraE4HFHNywHMv0,7915
-goose/_internal/conversation.py,sha256=zvKqLxJSCIIuhD7gjcSFhleYsLabu-ALl9woWFy3mQU,1766
-goose/_internal/flow.py,sha256=RShMsxgt49g1fZJ3rlwDHtI1j39lZzewx8hZ7DGN5kg,4124
+goose/_internal/agent.py,sha256=yNkX0lZueKiGxYsSwbZRNn88HfDBYbVpJLDfyr6Var0,8893
+goose/_internal/conversation.py,sha256=I0Ru5D7piOOQlmFhUpwEeQUQxOVq59yyHEDrmYhwPMI,1695
+goose/_internal/flow.py,sha256=05U2f5i8ofQWDjghhomwuuEPMk-ftzXn7BVl_s7pIf8,4203
 goose/_internal/result.py,sha256=vtJMfBxb9skfl8st2tn4hBmEq6qmXiJTme_B5QTgu2M,538
 goose/_internal/state.py,sha256=U4gM0K4MAlRFTpqenCYHX9TYGuhWVKIfa4yBeZ9Qc9s,7090
-goose/_internal/store.py,sha256=tWmKfa1-yq1jU6lT3l6kSOmVt2m3H7I1xLMTrxnUDI8,889
-goose/_internal/task.py,sha256=mhcmKDTBl993P3HP3PlNvQtl4gMYy4FMYeQ9xrg5aPk,6252
+goose/_internal/store.py,sha256=GMW0wBpxESmRBLfL_lFKEi9x2P6Wd6-gZ7AWjWBTUmA,904
+goose/_internal/task.py,sha256=MXBVLepFSphkSbGgzh7U7QMRXDvz_4MNet_EsrlAKTQ,6244
 goose/_internal/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 goose/_internal/types/agent.py,sha256=g0KD-aPWZlUGBx72AwQd3LeniFxHATeflZ7191QjFZA,2696
 goose/_internal/types/telemetry.py,sha256=7zeqyDDxf95puirNM6Gr9VFuxoDshXcV1__V0tiMswE,3663
-goose_py-0.10.1.dist-info/METADATA,sha256=L2yzL8ZW09_75wmrK5YSeEZ2H0RkrODL0zWm1nWW-uA,442
-goose_py-0.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-goose_py-0.10.1.dist-info/RECORD,,
+goose_py-0.10.2.dist-info/METADATA,sha256=VoLeEDnKj2PfjzVyJCt8eSQQygbFyWFihpADvJ4DTLw,442
+goose_py-0.10.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+goose_py-0.10.2.dist-info/RECORD,,