goose-py 0.9.14__tar.gz → 0.9.16__tar.gz

{goose_py-0.9.14 → goose_py-0.9.16}/.github/workflows/publish.yml

@@ -45,4 +45,3 @@ jobs:
 
       - name: Publish package
         run: uv publish
-        continue-on-error: true

{goose_py-0.9.14 → goose_py-0.9.16}/.stubs/litellm/__init__.pyi

@@ -1,4 +1,5 @@
-from typing import Any, Literal, NotRequired, TypedDict
+from typing import Literal, NotRequired, TypedDict
+from pydantic import BaseModel
 
 _LiteLLMGeminiModel = Literal[
     "vertex_ai/gemini-1.5-flash",
@@ -28,11 +29,6 @@ class _LiteLLMMessage(TypedDict):
     content: list[_LiteLLMTextMessageContent | _LiteLLMMediaMessageContent]
     cache_control: NotRequired[_LiteLLMCacheControl]
 
-class _LiteLLMResponseFormat(TypedDict):
-    type: Literal["json_object"]
-    response_schema: dict[str, Any]  # must be a valid JSON schema
-    enforce_validation: NotRequired[bool]
-
 class _LiteLLMModelResponseChoiceMessage:
     role: Literal["assistant"]
     content: str
@@ -60,7 +56,7 @@ async def acompletion(
     *,
     model: _LiteLLMGeminiModel,
     messages: list[_LiteLLMMessage],
-    response_format: _LiteLLMResponseFormat | None = None,
+    response_format: type[BaseModel] | None = None,
     max_tokens: int | None = None,
     temperature: float = 1.0,
 ) -> ModelResponse: ...

{goose_py-0.9.14 → goose_py-0.9.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: goose-py
-Version: 0.9.14
+Version: 0.9.16
 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.9.14 → goose_py-0.9.16}/goose/_internal/agent.py

@@ -7,7 +7,7 @@ from litellm import acompletion
 from pydantic import BaseModel, computed_field
 
 from .result import Result, TextResult
-from .types.agent import AIModel, AssistantMessage, SystemMessage, UserMessage
+from .types.agent import AIModel, LLMMessage
 
 
 class AgentResponseDump(TypedDict):
@@ -51,8 +51,8 @@ class AgentResponse[R: BaseModel | str](BaseModel):
     flow_name: str
     task_name: str
     model: AIModel
-    system: SystemMessage | None = None
-    input_messages: list[UserMessage | AssistantMessage]
+    system: LLMMessage | None = None
+    input_messages: list[LLMMessage]
     input_tokens: int
     output_tokens: int
     start_time: datetime
@@ -82,13 +82,13 @@ class AgentResponse[R: BaseModel | str](BaseModel):
         if self.system is None:
             minimized_system_message = ""
         else:
-            minimized_system_message = self.system.render()
+            minimized_system_message = self.system
             for part in minimized_system_message["content"]:
                 if part["type"] == "image_url":
                     part["image_url"] = "__MEDIA__"
             minimized_system_message = json.dumps(minimized_system_message)
 
-        minimized_input_messages = [message.render() for message in self.input_messages]
+        minimized_input_messages = [message for message in self.input_messages]
         for message in minimized_input_messages:
             for part in message["content"]:
                 if part["type"] == "image_url":
@@ -135,29 +135,24 @@ class Agent:
     async def __call__[R: Result](
         self,
         *,
-        messages: list[UserMessage | AssistantMessage],
+        messages: list[LLMMessage],
         model: AIModel,
         task_name: str,
         response_model: type[R] = TextResult,
-        system: SystemMessage | None = None,
+        system: LLMMessage | None = None,
     ) -> R:
         start_time = datetime.now()
-        rendered_messages = [message.render() for message in messages]
         if system is not None:
-            rendered_messages.insert(0, system.render())
+            messages.insert(0, system)
 
         if response_model is TextResult:
-            response = await acompletion(model=model.value, messages=rendered_messages)
+            response = await acompletion(model=model.value, messages=messages)
             parsed_response = response_model.model_validate({"text": response.choices[0].message.content})
         else:
             response = await acompletion(
                 model=model.value,
-                messages=rendered_messages,
-                response_format={
-                    "type": "json_object",
-                    "response_schema": response_model.model_json_schema(),
-                    "enforce_validation": True,
-                },
+                messages=messages,
+                response_format=response_model,
             )
             parsed_response = response_model.model_validate_json(response.choices[0].message.content)
 

goose_py-0.9.16/goose/_internal/conversation.py

@@ -0,0 +1,52 @@
+from typing import Self
+
+from pydantic import BaseModel
+
+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]
+    assistant_messages: list[R | str]
+    context: SystemMessage | None = None
+
+    @property
+    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())
+
+        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())
+            else:
+                messages.append(AssistantMessage(text=message.model_dump_json()).render())
+
+            messages.append(self.user_messages[message_index].render())
+
+        if len(self.assistant_messages) > len(self.user_messages):
+            message = self.assistant_messages[-1]
+            if isinstance(message, str):
+                messages.append(AssistantMessage(text=message).render())
+            else:
+                messages.append(AssistantMessage(text=message.model_dump_json()).render())
+
+        return messages
+
+    def undo(self) -> Self:
+        if len(self.user_messages) == 0:
+            raise Honk("Cannot undo, no user messages")
+
+        if len(self.assistant_messages) == 0:
+            raise Honk("Cannot undo, no assistant messages")
+
+        self.user_messages.pop()
+        self.assistant_messages.pop()
+        return self

{goose_py-0.9.14 → goose_py-0.9.16}/goose/_internal/state.py

@@ -4,15 +4,11 @@ from typing import TYPE_CHECKING, Any, NewType, Self
 
 from pydantic import BaseModel, ConfigDict
 
-from ..errors import Honk
-from .agent import (
-    Agent,
-    IAgentLogger,
-    SystemMessage,
-    UserMessage,
-)
-from .conversation import Conversation
-from .result import Result
+from goose._internal.agent import Agent, IAgentLogger
+from goose._internal.conversation import Conversation
+from goose._internal.result import Result
+from goose._internal.types.agent import SystemMessage, UserMessage
+from goose.errors import Honk
 
 if TYPE_CHECKING:
     from goose._internal.task import Task
@@ -32,10 +28,11 @@ class NodeState[ResultT: Result](BaseModel):
 
     @property
     def result(self) -> ResultT:
-        if len(self.conversation.result_messages) == 0:
-            raise Honk("Node awaiting response, has no result")
+        for message in reversed(self.conversation.assistant_messages):
+            if isinstance(message, Result):
+                return message
 
-        return self.conversation.result_messages[-1]
+        raise Honk("Node awaiting response, has no result")
 
     def set_context(self, *, context: SystemMessage) -> Self:
         self.conversation.context = context
@@ -48,24 +45,33 @@ class NodeState[ResultT: Result](BaseModel):
         new_hash: int | None = None,
         overwrite: bool = False,
     ) -> Self:
-        if overwrite and len(self.conversation.result_messages) > 0:
-            self.conversation.result_messages[-1] = result
+        if overwrite and len(self.conversation.assistant_messages) > 0:
+            self.conversation.assistant_messages[-1] = result
         else:
-            self.conversation.result_messages.append(result)
+            self.conversation.assistant_messages.append(result)
         if new_hash is not None:
             self.last_hash = new_hash
         return self
 
+    def add_answer(self, *, answer: str) -> Self:
+        self.conversation.assistant_messages.append(answer)
+        return self
+
     def add_user_message(self, *, message: UserMessage) -> Self:
         self.conversation.user_messages.append(message)
         return self
 
     def edit_last_result(self, *, result: ResultT) -> Self:
-        if len(self.conversation.result_messages) == 0:
+        if len(self.conversation.assistant_messages) == 0:
             raise Honk("Node awaiting response, has no result")
 
-        self.conversation.result_messages[-1] = result
-        return self
+        for message_index, message in enumerate(reversed(self.conversation.assistant_messages)):
+            if isinstance(message, Result):
+                index = len(self.conversation.assistant_messages) - message_index - 1
+                self.conversation.assistant_messages[index] = result
+                return self
+
+        raise Honk("Node awaiting response, has no result")
 
     def undo(self) -> Self:
         self.conversation.undo()
@@ -117,7 +123,7 @@ class FlowRun[FlowArgumentsT: FlowArguments]:
             return NodeState[task.result_type](
                 task_name=task.name,
                 index=index,
-                conversation=Conversation[task.result_type](user_messages=[], result_messages=[]),
+                conversation=Conversation[task.result_type](user_messages=[], assistant_messages=[]),
                 last_hash=0,
             )
 

{goose_py-0.9.14 → goose_py-0.9.16}/goose/_internal/task.py

@@ -5,11 +5,10 @@ from typing import Any, overload
 from pydantic import BaseModel
 
 from ..errors import Honk
-from .agent import Agent, AIModel, SystemMessage, UserMessage
-from .conversation import Conversation
-from .result import Result, TextResult
+from .agent import Agent, AIModel
+from .result import Result
 from .state import FlowRun, NodeState, get_current_flow_run
-from .types.agent import AssistantMessage
+from .types.agent import SystemMessage, UserMessage
 
 
 class Task[**P, R: Result]:
@@ -19,12 +18,11 @@ class Task[**P, R: Result]:
         /,
         *,
         retries: int = 0,
-        adapter_model: AIModel = AIModel.GEMINI_FLASH,
+        refinement_model: AIModel = AIModel.GEMINI_FLASH,
     ) -> None:
         self._generator = generator
         self._retries = retries
-        self._adapter_model = adapter_model
-        self._adapter_model = adapter_model
+        self._refinement_model = refinement_model
 
     @property
     def result_type(self) -> type[R]:
@@ -46,6 +44,25 @@ class Task[**P, R: Result]:
         else:
             return state.result
 
+    async def ask(self, *, user_message: UserMessage, context: SystemMessage | None = None, index: int = 0) -> str:
+        flow_run = self.__get_current_flow_run()
+        node_state = flow_run.get(task=self, index=index)
+
+        if len(node_state.conversation.assistant_messages) == 0:
+            raise Honk("Cannot ask about a task that has not been initially generated")
+
+        node_state.add_user_message(message=user_message)
+        answer = await flow_run.agent(
+            messages=node_state.conversation.render(),
+            model=self._refinement_model,
+            task_name=f"ask--{self.name}",
+            system=context.render() if context is not None else None,
+        )
+        node_state.add_answer(answer=answer.text)
+        flow_run.upsert_node_state(node_state)
+
+        return answer.text
+
     async def refine(
         self,
         *,
@@ -56,14 +73,20 @@ class Task[**P, R: Result]:
         flow_run = self.__get_current_flow_run()
         node_state = flow_run.get(task=self, index=index)
 
-        if len(node_state.conversation.result_messages) == 0:
+        if len(node_state.conversation.assistant_messages) == 0:
             raise Honk("Cannot refine a task that has not been initially generated")
 
         if context is not None:
             node_state.set_context(context=context)
         node_state.add_user_message(message=user_message)
 
-        result = await self.__adapt(conversation=node_state.conversation, agent=flow_run.agent)
+        result = await flow_run.agent(
+            messages=node_state.conversation.render(),
+            model=self._refinement_model,
+            task_name=f"refine--{self.name}",
+            system=context.render() if context is not None else None,
+            response_model=self.result_type,
+        )
         node_state.add_result(result=result)
         flow_run.upsert_node_state(node_state)
 
@@ -88,28 +111,6 @@ class Task[**P, R: Result]:
         flow_run.upsert_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:
         def update_hash(argument: Any, current_hash: Any = hashlib.sha256()) -> None:
             try:
@@ -148,20 +149,20 @@ 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, adapter_model: AIModel = AIModel.GEMINI_FLASH
+    *, retries: int = 0, refinement_model: AIModel = AIModel.GEMINI_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: AIModel = AIModel.GEMINI_FLASH,
+    refinement_model: AIModel = AIModel.GEMINI_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, adapter_model=adapter_model)
+            return Task(fn, retries=retries, refinement_model=refinement_model)
 
         return decorator
 
-    return Task(generator, retries=retries, adapter_model=adapter_model)
+    return Task(generator, retries=retries, refinement_model=refinement_model)

{goose_py-0.9.14 → goose_py-0.9.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "goose-py"
-version = "0.9.14"
+version = "0.9.16"
 description = "A tool for AI workflows based on human-computer collaboration and structured output."
 readme = "README.md"
 authors = [

{goose_py-0.9.14 → goose_py-0.9.16}/tests/test_agent.py

@@ -4,8 +4,7 @@ import pytest
 from pytest_mock import MockerFixture
 
 from goose import Agent, FlowArguments, TextResult, flow, task
-from goose._internal.types.agent import MessagePart
-from goose.agent import AgentResponse, AIModel, IAgentLogger, UserMessage
+from goose.agent import AgentResponse, AIModel, IAgentLogger
 
 
 class TestFlowArguments(FlowArguments):
@@ -29,7 +28,7 @@ def mock_litellm(mocker: MockerFixture) -> Mock:
 @task
 async def use_agent(*, agent: Agent) -> TextResult:
     return await agent(
-        messages=[UserMessage(parts=[MessagePart(content="Hello")])],
+        messages=[{"role": "user", "content": [{"type": "text", "text": "Hello"}]}],
         model=AIModel.GEMINI_FLASH_8B,
         task_name="greet",
     )

goose_py-0.9.16/tests/test_ask.py

@@ -0,0 +1,124 @@
+from unittest.mock import Mock
+
+import pytest
+from pytest_mock import MockerFixture
+
+from goose import Agent, FlowArguments, flow, task
+from goose._internal.result import TextResult
+from goose._internal.types.agent import ContentType, MessagePart, UserMessage
+from goose.errors import Honk
+
+
+class MockLiteLLMResponse:
+    def __init__(self, *, response: str, prompt_tokens: int, completion_tokens: int) -> None:
+        self.choices = [Mock(message=Mock(content=response))]
+        self.usage = Mock(prompt_tokens=prompt_tokens, completion_tokens=completion_tokens)
+
+
+@pytest.fixture
+def mock_litellm(mocker: MockerFixture) -> Mock:
+    return mocker.patch(
+        "goose._internal.agent.acompletion",
+        return_value=MockLiteLLMResponse(response="Here's the explanation!", prompt_tokens=10, completion_tokens=10),
+    )
+
+
+class MyFlowArguments(FlowArguments):
+    pass
+
+
+@task
+async def basic_task(*, flow_arguments: MyFlowArguments) -> TextResult:
+    return TextResult(text="Hello, world!")
+
+
+@flow
+async def my_flow(*, flow_arguments: MyFlowArguments, agent: Agent) -> None:
+    await basic_task(flow_arguments=flow_arguments)
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("mock_litellm")
+async def test_ask_adds_to_conversation():
+    """Test that ask mode adds messages to conversation but doesn't change result"""
+
+    async with my_flow.start_run(run_id="1") as run:
+        await my_flow.generate(MyFlowArguments())
+
+        # Get the initial result
+        node_state = run.get(task=basic_task)
+        original_result = node_state.result
+
+        # Ask a follow-up question
+        response = await basic_task.ask(
+            user_message=UserMessage(
+                parts=[MessagePart(content="Can you explain how you got that?", content_type=ContentType.TEXT)]
+            )
+        )
+
+        # Verify the response exists and makes sense
+        assert response == "Here's the explanation!"
+
+        # Get updated conversation
+        node_state = run.get(task=basic_task)
+        conversation = node_state.conversation
+
+        # Verify that asking didn't change the original result
+        assert node_state.result == original_result
+
+        # Verify the conversation includes the new messages
+        assert len(conversation.user_messages) == 1
+        assert len(conversation.assistant_messages) == 2  # Original result + response
+
+        # Verify the last messages are our question and the response
+        assert conversation.user_messages[-1].parts[0].content == "Can you explain how you got that?"
+        assert isinstance(conversation.assistant_messages[-1], str)
+        assert conversation.assistant_messages[-1] == "Here's the explanation!"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("mock_litellm")
+async def test_ask_requires_completed_task():
+    """Test that ask mode only works on tasks that haven't been run"""
+
+    async with my_flow.start_run(run_id="2") as run:
+        # Set up flow arguments but don't run the task
+        run.set_flow_arguments(MyFlowArguments())
+
+        # Try to ask before running the task
+        with pytest.raises(Honk, match="Cannot ask about a task that has not been initially generated"):
+            await basic_task.ask(
+                user_message=UserMessage(parts=[MessagePart(content="Can you explain?", content_type=ContentType.TEXT)])
+            )
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("mock_litellm")
+async def test_ask_multiple_questions():
+    """Test that we can ask multiple follow-up questions"""
+
+    async with my_flow.start_run(run_id="3") as run:
+        await my_flow.generate(MyFlowArguments())
+
+        # Ask several questions
+        responses: list[str] = []
+        questions = ["Why is that the answer?", "Can you explain it differently?", "What if we added 1 more?"]
+
+        for question in questions:
+            response = await basic_task.ask(
+                user_message=UserMessage(parts=[MessagePart(content=question, content_type=ContentType.TEXT)])
+            )
+            responses.append(response)
+
+        # Verify we got responses for all questions
+        assert len(responses) == len(questions)
+        assert all(response == "Here's the explanation!" for response in responses)
+
+        # Get conversation to verify messages
+        node_state = run.get(task=basic_task)
+        conversation = node_state.conversation
+
+        # Verify the conversation includes all Q&A pairs
+        # Should have: initial result + (question + answer for each question)
+        assert len(conversation.user_messages) == len(questions)
+        assert len(conversation.assistant_messages) == len(questions) + 1  # +1 for initial result

{goose_py-0.9.14 → goose_py-0.9.16}/tests/test_refining.py

@@ -1,9 +1,7 @@
 import random
 import string
-from unittest.mock import Mock
 
 import pytest
-from pytest_mock import MockerFixture
 
 from goose import Agent, FlowArguments, Result, flow, task
 from goose._internal.types.agent import MessagePart
@@ -28,15 +26,6 @@ async def generate_random_word(*, n_characters: int) -> GeneratedWord:
     return GeneratedWord(word="".join(random.sample(string.ascii_lowercase, n_characters)))
 
 
-@pytest.fixture
-def generate_random_word_adapter(mocker: MockerFixture) -> Mock:
-    return mocker.patch.object(
-        generate_random_word,
-        "_Task__adapt",
-        return_value=GeneratedWord(word="__ADAPTED__"),
-    )
-
-
 @task
 async def make_sentence(*, words: list[GeneratedWord]) -> GeneratedSentence:
     return GeneratedSentence(sentence=" ".join([word.word for word in words]))
@@ -49,7 +38,6 @@ async def sentence(*, flow_arguments: MyFlowArguments, agent: Agent) -> None:
 
 
 @pytest.mark.asyncio
-@pytest.mark.usefixtures("generate_random_word_adapter")
 async def test_refining() -> None:
     async with sentence.start_run(run_id="1") as first_run:
         await sentence.generate(MyFlowArguments())
@@ -59,20 +47,22 @@ async def test_refining() -> None:
 
     # imagine this is a new process
     async with sentence.start_run(run_id="1") as second_run:
-        await generate_random_word.refine(
+        result = await generate_random_word.refine(
             user_message=UserMessage(parts=[MessagePart(content="Change it")]),
             context=SystemMessage(parts=[MessagePart(content="Extra info")]),
         )
+        # Since refine now directly returns the result from the agent call
+        assert isinstance(result, GeneratedWord)
 
     random_words = second_run.get_all(task=generate_random_word)
     assert len(random_words) == 3
-    assert random_words[0].result.word == "__ADAPTED__"  # adapted
-    assert random_words[1].result.word != "__ADAPTED__"  # not adapted
-    assert random_words[2].result.word != "__ADAPTED__"  # not adapted
+    # Remove the __ADAPTED__ check since that was specific to the old __adapt method
+    assert isinstance(random_words[0].result, GeneratedWord)
+    assert isinstance(random_words[1].result, GeneratedWord)
+    assert isinstance(random_words[2].result, GeneratedWord)
 
 
 @pytest.mark.asyncio
-@pytest.mark.usefixtures("generate_random_word_adapter")
 async def test_refining_before_generate_fails() -> None:
     with pytest.raises(Honk):
         async with sentence.start_run(run_id="2"):

{goose_py-0.9.14 → goose_py-0.9.16}/tests/test_state.py

@@ -29,11 +29,10 @@ async def generate_random_word(*, n_characters: int) -> GeneratedWord:
 
 @pytest.fixture
 def generate_random_word_adapter(mocker: MockerFixture) -> Mock:
-    return mocker.patch.object(
-        generate_random_word,
-        "_Task__adapt",
-        return_value=GeneratedWord(word="__ADAPTED__"),
-    )
+    mock_result = GeneratedWord(word="__REFINED__")
+    mock = mocker.patch("goose._internal.agent.Agent.__call__", autospec=True)
+    mock.return_value = mock_result
+    return mock
 
 
 @task
@@ -81,7 +80,7 @@ async def test_state_undo() -> None:
     async with with_state.start_run(run_id="2") as run:
         generate_random_word.undo()
 
-    assert run.get(task=generate_random_word).result.word != "__ADAPTED__"
+    assert run.get(task=generate_random_word).result.word != "__REFINED__"
 
 
 @pytest.mark.asyncio

{goose_py-0.9.14 → goose_py-0.9.16}/uv.lock

@@ -234,7 +234,7 @@ wheels = [
 
 [[package]]
 name = "goose-py"
-version = "0.9.14"
+version = "0.9.16"
 source = { editable = "." }
 dependencies = [
     { name = "jsonpath-ng" },

goose_py-0.9.14/goose/_internal/conversation.py

@@ -1,35 +0,0 @@
-from typing import Self
-
-from pydantic import BaseModel
-
-from .result import Result
-from .types.agent import AssistantMessage, LLMMessage, SystemMessage, UserMessage
-
-
-class Conversation[R: Result](BaseModel):
-    user_messages: list[UserMessage]
-    result_messages: list[R]
-    context: SystemMessage | None = None
-
-    @property
-    def awaiting_response(self) -> bool:
-        return len(self.user_messages) == len(self.result_messages)
-
-    def render(self) -> list[LLMMessage]:
-        messages: list[LLMMessage] = []
-        if self.context is not None:
-            messages.append(self.context.render())
-
-        for message_index in range(len(self.user_messages)):
-            messages.append(AssistantMessage(text=self.result_messages[message_index].model_dump_json()).render())
-            messages.append(self.user_messages[message_index].render())
-
-        if len(self.result_messages) > len(self.user_messages):
-            messages.append(AssistantMessage(text=self.result_messages[-1].model_dump_json()).render())
-
-        return messages
-
-    def undo(self) -> Self:
-        self.user_messages.pop()
-        self.result_messages.pop()
-        return self