goose-py 0.4.1__tar.gz → 0.5.0__tar.gz

{goose_py-0.4.1 → goose_py-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goose-py
-Version: 0.4.1
+Version: 0.5.0
 Summary: A tool for AI workflows based on human-computer collaboration and structured output.
 Home-page: https://github.com/chelle-ai/goose
 Keywords: ai,yaml,configuration,llm

{goose_py-0.4.1 → goose_py-0.5.0}/goose/flow.py

@@ -18,14 +18,15 @@ from pydantic import BaseModel
 from goose.agent import (
     Agent,
     AssistantMessage,
+    GeminiModel,
     IAgentLogger,
     LLMMessage,
     SystemMessage,
     UserMessage,
 )
 from goose.errors import Honk
+from goose.result import Result, TextResult
 from goose.store import IFlowRunStore, InMemoryFlowRunStore
-from goose.result import Result
 
 SerializedFlowRun = NewType("SerializedFlowRun", str)
 
@@ -65,7 +66,9 @@ class Conversation[R: Result](BaseModel):
 class IAdapter[ResultT: Result](Protocol):
     __code__: CodeType
 
-    async def __call__(self, *, conversation: Conversation[ResultT]) -> ResultT: ...
+    async def __call__(
+        self, *, conversation: Conversation[ResultT], agent: Agent
+    ) -> ResultT: ...
 
 
 class NodeState[ResultT: Result](BaseModel):
@@ -307,10 +310,12 @@ class Task[**P, R: Result]:
         /,
         *,
         retries: int = 0,
+        adapter_model: GeminiModel = GeminiModel.FLASH,
     ) -> None:
         self._generator = generator
-        self._adapter: IAdapter[R] | None = None
         self._retries = retries
+        self._adapter_model = adapter_model
+        self._adapter_model = adapter_model
 
     @property
     def result_type(self) -> type[R]:
@@ -323,10 +328,6 @@ class Task[**P, R: Result]:
     def name(self) -> str:
         return self._generator.__name__
 
-    def adapter(self, adapter: IAdapter[R]) -> Self:
-        self._adapter = adapter
-        return self
-
     async def generate(
         self, state: NodeState[R], *args: P.args, **kwargs: P.kwargs
     ) -> R:
@@ -347,14 +348,14 @@ class Task[**P, R: Result]:
     ) -> R:
         flow_run = self.__get_current_flow_run()
         node_state = flow_run.get(task=self, index=index)
-        if self._adapter is None:
-            raise Honk("No adapter provided for Task")
 
         if context is not None:
             node_state.set_context(context=context)
         node_state.add_user_message(message=user_message)
 
-        result = await self._adapter(conversation=node_state.conversation)
+        result = await self.__adapt(
+            conversation=node_state.conversation, agent=flow_run.agent
+        )
         node_state.add_result(result=result)
         flow_run.add_node_state(node_state)
 
@@ -367,15 +368,34 @@ class Task[**P, R: Result]:
         flow_run.add_node_state(node_state)
         return result
 
+    async def __adapt(self, *, conversation: Conversation[R], agent: Agent) -> R:
+        messages: list[UserMessage | AssistantMessage] = []
+        for message_index in range(len(conversation.user_messages)):
+            user_message = conversation.user_messages[message_index]
+            result = conversation.result_messages[message_index]
+
+            if isinstance(result, TextResult):
+                assistant_text = result.text
+            else:
+                assistant_text = result.model_dump_json()
+            assistant_message = AssistantMessage(text=assistant_text)
+            messages.append(assistant_message)
+            messages.append(user_message)
+
+        return await agent(
+            messages=messages,
+            model=self._adapter_model,
+            task_name=f"adapt--{self.name}",
+            system=conversation.context,
+            response_model=self.result_type,
+        )
+
     def __hash_task_call(self, *args: P.args, **kwargs: P.kwargs) -> int:
         try:
             to_hash = str(
                 tuple(args)
                 + tuple(kwargs.values())
-                + (
-                    self._generator.__code__,
-                    self._adapter.__code__ if self._adapter is not None else None,
-                )
+                + (self._generator.__code__, self._adapter_model)
             )
             return hash(to_hash)
         except TypeError:
@@ -392,22 +412,23 @@ class Task[**P, R: Result]:
 def task[**P, R: Result](generator: Callable[P, Awaitable[R]], /) -> Task[P, R]: ...
 @overload
 def task[**P, R: Result](
-    *, retries: int = 0
+    *, retries: int = 0, adapter_model: GeminiModel = GeminiModel.FLASH
 ) -> Callable[[Callable[P, Awaitable[R]]], Task[P, R]]: ...
 def task[**P, R: Result](
     generator: Callable[P, Awaitable[R]] | None = None,
     /,
     *,
     retries: int = 0,
+    adapter_model: GeminiModel = GeminiModel.FLASH,
 ) -> Task[P, R] | Callable[[Callable[P, Awaitable[R]]], Task[P, R]]:
     if generator is None:
 
         def decorator(fn: Callable[P, Awaitable[R]]) -> Task[P, R]:
-            return Task(fn, retries=retries)
+            return Task(fn, retries=retries, adapter_model=adapter_model)
 
         return decorator
 
-    return Task(generator, retries=retries)
+    return Task(generator, retries=retries, adapter_model=adapter_model)
 
 
 @overload

{goose_py-0.4.1 → goose_py-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "goose-py"
-version = "0.4.1"
+version = "0.5.0"
 description = "A tool for AI workflows based on human-computer collaboration and structured output."
 authors = [
     "Nash Taylor <nash@chelle.ai>",