goose-py 0.9.15__py3-none-any.whl → 0.10.0__py3-none-any.whl

goose/_internal/agent.py

@@ -1,119 +1,15 @@
-import json
 import logging
 from datetime import datetime
-from typing import Any, ClassVar, Protocol, TypedDict
+from typing import Any, Literal, Protocol, overload
 
 from litellm import acompletion
-from pydantic import BaseModel, computed_field
-
-from .result import Result, TextResult
-from .types.agent import AIModel, AssistantMessage, SystemMessage, UserMessage
-
-
-class AgentResponseDump(TypedDict):
-    run_id: str
-    flow_name: str
-    task_name: str
-    model: str
-    system_message: str
-    input_messages: list[str]
-    output_message: str
-    input_cost: float
-    output_cost: float
-    total_cost: float
-    input_tokens: int
-    output_tokens: int
-    start_time: datetime
-    end_time: datetime
-    duration_ms: int
-
-
-class AgentResponse[R: BaseModel | str](BaseModel):
-    INPUT_CENTS_PER_MILLION_TOKENS: ClassVar[dict[AIModel, float]] = {
-        AIModel.VERTEX_FLASH_8B: 30,
-        AIModel.VERTEX_FLASH: 15,
-        AIModel.VERTEX_PRO: 500,
-        AIModel.GEMINI_FLASH_8B: 30,
-        AIModel.GEMINI_FLASH: 15,
-        AIModel.GEMINI_PRO: 500,
-    }
-    OUTPUT_CENTS_PER_MILLION_TOKENS: ClassVar[dict[AIModel, float]] = {
-        AIModel.VERTEX_FLASH_8B: 30,
-        AIModel.VERTEX_FLASH: 15,
-        AIModel.VERTEX_PRO: 500,
-        AIModel.GEMINI_FLASH_8B: 30,
-        AIModel.GEMINI_FLASH: 15,
-        AIModel.GEMINI_PRO: 500,
-    }
-
-    response: R
-    run_id: str
-    flow_name: str
-    task_name: str
-    model: AIModel
-    system: SystemMessage | None = None
-    input_messages: list[UserMessage | AssistantMessage]
-    input_tokens: int
-    output_tokens: int
-    start_time: datetime
-    end_time: datetime
-
-    @computed_field
-    @property
-    def duration_ms(self) -> int:
-        return int((self.end_time - self.start_time).total_seconds() * 1000)
-
-    @computed_field
-    @property
-    def input_cost(self) -> float:
-        return self.INPUT_CENTS_PER_MILLION_TOKENS[self.model] * self.input_tokens / 1_000_000
-
-    @computed_field
-    @property
-    def output_cost(self) -> float:
-        return self.OUTPUT_CENTS_PER_MILLION_TOKENS[self.model] * self.output_tokens / 1_000_000
-
-    @computed_field
-    @property
-    def total_cost(self) -> float:
-        return self.input_cost + self.output_cost
-
-    def minimized_dump(self) -> AgentResponseDump:
-        if self.system is None:
-            minimized_system_message = ""
-        else:
-            minimized_system_message = self.system.render()
-            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]
-        for message in minimized_input_messages:
-            for part in message["content"]:
-                if part["type"] == "image_url":
-                    part["image_url"] = "__MEDIA__"
-        minimized_input_messages = [json.dumps(message) for message in minimized_input_messages]
-
-        output_message = self.response.model_dump_json() if isinstance(self.response, BaseModel) else self.response
-
-        return {
-            "run_id": self.run_id,
-            "flow_name": self.flow_name,
-            "task_name": self.task_name,
-            "model": self.model.value,
-            "system_message": minimized_system_message,
-            "input_messages": minimized_input_messages,
-            "output_message": output_message,
-            "input_tokens": self.input_tokens,
-            "output_tokens": self.output_tokens,
-            "input_cost": self.input_cost,
-            "output_cost": self.output_cost,
-            "total_cost": self.total_cost,
-            "start_time": self.start_time,
-            "end_time": self.end_time,
-            "duration_ms": self.duration_ms,
-        }
+from pydantic import ValidationError
+
+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):
@@ -132,27 +28,26 @@ class Agent:
         self.run_id = run_id
         self.logger = logger
 
-    async def __call__[R: Result](
+    async def generate[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,
+                messages=messages,
                 response_format=response_model,
             )
             parsed_response = response_model.model_validate_json(response.choices[0].message.content)
@@ -178,3 +73,173 @@ class Agent:
             logging.info(agent_response.model_dump())
 
         return parsed_response
+
+    async def ask(
+        self, *, messages: list[LLMMessage], model: AIModel, task_name: str, system: LLMMessage | None = None
+    ) -> str:
+        start_time = datetime.now()
+
+        if system is not None:
+            messages.insert(0, system)
+        response = await acompletion(model=model.value, messages=messages)
+
+        end_time = datetime.now()
+        agent_response = AgentResponse(
+            response=response.choices[0].message.content,
+            run_id=self.run_id,
+            flow_name=self.flow_name,
+            task_name=task_name,
+            model=model,
+            system=system,
+            input_messages=messages,
+            input_tokens=response.usage.prompt_tokens,
+            output_tokens=response.usage.completion_tokens,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+        if self.logger is not None:
+            await self.logger(response=agent_response)
+        else:
+            logging.info(agent_response.model_dump())
+
+        return response.choices[0].message.content
+
+    async def refine[R: Result](
+        self,
+        *,
+        messages: list[LLMMessage],
+        model: AIModel,
+        task_name: str,
+        response_model: type[R],
+        system: LLMMessage | None = None,
+    ) -> R:
+        start_time = datetime.now()
+
+        if system is not None:
+            messages.insert(0, system)
+
+        find_replace_response = await acompletion(
+            model=model.value, messages=messages, response_format=FindReplaceResponse
+        )
+        parsed_find_replace_response = FindReplaceResponse.model_validate_json(
+            find_replace_response.choices[0].message.content
+        )
+
+        end_time = datetime.now()
+        agent_response = AgentResponse(
+            response=parsed_find_replace_response,
+            run_id=self.run_id,
+            flow_name=self.flow_name,
+            task_name=task_name,
+            model=model,
+            system=system,
+            input_messages=messages,
+            input_tokens=find_replace_response.usage.prompt_tokens,
+            output_tokens=find_replace_response.usage.completion_tokens,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+        if self.logger is not None:
+            await self.logger(response=agent_response)
+        else:
+            logging.info(agent_response.model_dump())
+
+        refined_response = self.__apply_find_replace(
+            result=self.__find_last_result(messages=messages, response_model=response_model),
+            find_replace_response=parsed_find_replace_response,
+            response_model=response_model,
+        )
+
+        return refined_response
+
+    @overload
+    async def __call__[R: Result](
+        self,
+        *,
+        messages: list[LLMMessage],
+        model: AIModel,
+        task_name: str,
+        mode: Literal["generate"],
+        response_model: type[R],
+        system: LLMMessage | None = None,
+    ) -> R: ...
+
+    @overload
+    async def __call__[R: Result](
+        self,
+        *,
+        messages: list[LLMMessage],
+        model: AIModel,
+        task_name: str,
+        mode: Literal["ask"],
+        response_model: type[R] = TextResult,
+        system: LLMMessage | None = None,
+    ) -> str: ...
+
+    @overload
+    async def __call__[R: Result](
+        self,
+        *,
+        messages: list[LLMMessage],
+        model: AIModel,
+        task_name: str,
+        response_model: type[R],
+        mode: Literal["refine"],
+        system: LLMMessage | None = None,
+    ) -> R: ...
+
+    @overload
+    async def __call__[R: Result](
+        self,
+        *,
+        messages: list[LLMMessage],
+        model: AIModel,
+        task_name: str,
+        response_model: type[R],
+        system: LLMMessage | None = None,
+    ) -> R: ...
+
+    async def __call__[R: Result](
+        self,
+        *,
+        messages: list[LLMMessage],
+        model: AIModel,
+        task_name: str,
+        response_model: type[R] = TextResult,
+        mode: Literal["generate", "ask", "refine"] = "generate",
+        system: LLMMessage | None = None,
+    ) -> R | str:
+        match mode:
+            case "generate":
+                return await self.generate(
+                    messages=messages, model=model, task_name=task_name, response_model=response_model, system=system
+                )
+            case "ask":
+                return await self.ask(messages=messages, model=model, task_name=task_name, system=system)
+            case "refine":
+                return await self.refine(
+                    messages=messages, model=model, task_name=task_name, response_model=response_model, system=system
+                )
+
+    def __apply_find_replace[R: Result](
+        self, *, result: R, find_replace_response: FindReplaceResponse, response_model: type[R]
+    ) -> R:
+        dumped_result = result.model_dump_json()
+        for replacement in find_replace_response.replacements:
+            dumped_result = dumped_result.replace(replacement.find, replacement.replace)
+
+        return response_model.model_validate_json(dumped_result)
+
+    def __find_last_result[R: Result](self, *, messages: list[LLMMessage], response_model: type[R]) -> R:
+        for message in reversed(messages):
+            if message["role"] == "assistant":
+                try:
+                    only_part = message["content"][0]
+                    if only_part["type"] == "text":
+                        return response_model.model_validate_json(only_part["text"])
+                except ValidationError:
+                    continue
+
+        raise Honk("No last result found, failed to refine")

goose/_internal/conversation.py

@@ -2,18 +2,20 @@ 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]
-    result_messages: list[R]
+    assistant_messages: list[R | str]
     context: SystemMessage | None = None
 
     @property
     def awaiting_response(self) -> bool:
-        return len(self.user_messages) == len(self.result_messages)
+        return len(self.user_messages) == len(self.assistant_messages)
 
     def render(self) -> list[LLMMessage]:
         messages: list[LLMMessage] = []
@@ -21,15 +23,30 @@ class Conversation[R: Result](BaseModel):
             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())
+            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.result_messages) > len(self.user_messages):
-            messages.append(AssistantMessage(text=self.result_messages[-1].model_dump_json()).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.result_messages.pop()
+        self.assistant_messages.pop()
         return self

goose/_internal/result.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class Result(BaseModel):
@@ -7,3 +7,14 @@ class Result(BaseModel):
 
 class TextResult(Result):
     text: str
+
+
+class Replacement(BaseModel):
+    find: str = Field(description="Text to find, to be replaced with `replace`")
+    replace: str = Field(description="Text to replace `find` with")
+
+
+class FindReplaceResponse(BaseModel):
+    replacements: list[Replacement] = Field(
+        description="List of replacements to make in the previous result to satisfy the user's request"
+    )

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/_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,26 @@ 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,
+            mode="ask",
+        )
+        node_state.add_answer(answer=answer)
+        flow_run.upsert_node_state(node_state)
+
+        return answer
+
     async def refine(
         self,
         *,
@@ -56,14 +74,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 +112,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 +150,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/_internal/types/telemetry.py

@@ -0,0 +1,113 @@
+import json
+from datetime import datetime
+from typing import ClassVar, TypedDict
+
+from pydantic import BaseModel, computed_field
+
+from ..types.agent import AIModel, LLMMessage
+
+
+class AgentResponseDump(TypedDict):
+    run_id: str
+    flow_name: str
+    task_name: str
+    model: str
+    system_message: str
+    input_messages: list[str]
+    output_message: str
+    input_cost: float
+    output_cost: float
+    total_cost: float
+    input_tokens: int
+    output_tokens: int
+    start_time: datetime
+    end_time: datetime
+    duration_ms: int
+
+
+class AgentResponse[R: BaseModel | str](BaseModel):
+    INPUT_DOLLARS_PER_MILLION_TOKENS: ClassVar[dict[AIModel, float]] = {
+        AIModel.VERTEX_FLASH_8B: 0.30,
+        AIModel.VERTEX_FLASH: 0.15,
+        AIModel.VERTEX_PRO: 5.00,
+        AIModel.GEMINI_FLASH_8B: 0.30,
+        AIModel.GEMINI_FLASH: 0.15,
+        AIModel.GEMINI_PRO: 5.00,
+    }
+    OUTPUT_DOLLARS_PER_MILLION_TOKENS: ClassVar[dict[AIModel, float]] = {
+        AIModel.VERTEX_FLASH_8B: 0.30,
+        AIModel.VERTEX_FLASH: 0.15,
+        AIModel.VERTEX_PRO: 5.00,
+        AIModel.GEMINI_FLASH_8B: 0.30,
+        AIModel.GEMINI_FLASH: 0.15,
+        AIModel.GEMINI_PRO: 5.00,
+    }
+
+    response: R
+    run_id: str
+    flow_name: str
+    task_name: str
+    model: AIModel
+    system: LLMMessage | None = None
+    input_messages: list[LLMMessage]
+    input_tokens: int
+    output_tokens: int
+    start_time: datetime
+    end_time: datetime
+
+    @computed_field
+    @property
+    def duration_ms(self) -> int:
+        return int((self.end_time - self.start_time).total_seconds() * 1000)
+
+    @computed_field
+    @property
+    def input_cost(self) -> float:
+        return self.INPUT_DOLLARS_PER_MILLION_TOKENS[self.model] * self.input_tokens / 1_000_000
+
+    @computed_field
+    @property
+    def output_cost(self) -> float:
+        return self.OUTPUT_DOLLARS_PER_MILLION_TOKENS[self.model] * self.output_tokens / 1_000_000
+
+    @computed_field
+    @property
+    def total_cost(self) -> float:
+        return self.input_cost + self.output_cost
+
+    def minimized_dump(self) -> AgentResponseDump:
+        if self.system is None:
+            minimized_system_message = ""
+        else:
+            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 for message in self.input_messages]
+        for message in minimized_input_messages:
+            for part in message["content"]:
+                if part["type"] == "image_url":
+                    part["image_url"] = "__MEDIA__"
+        minimized_input_messages = [json.dumps(message) for message in minimized_input_messages]
+
+        output_message = self.response.model_dump_json() if isinstance(self.response, BaseModel) else self.response
+
+        return {
+            "run_id": self.run_id,
+            "flow_name": self.flow_name,
+            "task_name": self.task_name,
+            "model": self.model.value,
+            "system_message": minimized_system_message,
+            "input_messages": minimized_input_messages,
+            "output_message": output_message,
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "input_cost": self.input_cost,
+            "output_cost": self.output_cost,
+            "total_cost": self.total_cost,
+            "start_time": self.start_time,
+            "end_time": self.end_time,
+            "duration_ms": self.duration_ms,
+        }

{goose_py-0.9.15.dist-info → goose_py-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: goose-py
-Version: 0.9.15
+Version: 0.10.0
 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.15.dist-info → goose_py-0.10.0.dist-info}/RECORD

@@ -5,15 +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=x3uyPrV5gezsjslm_9NFuakufkhQhcireY8GkHniZSs,5859
-goose/_internal/conversation.py,sha256=zbMvP4oxhKAzATVEXZfGVKXWfEjh472MYKhmyJzSLgI,1172
+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/result.py,sha256=-eZJn-2sPo7rHZ38Sz6IAHXqiJ-Ss39esEoFGimJEBI,155
-goose/_internal/state.py,sha256=pI-C37Ybazo7EJPbZklxbiCYFy3u4I031NKBr8Jm_CI,6534
+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=qjpX_wIQ2jKreMjrRy1SVedsuVzLXuOLgcyPstrgWfE,6176
+goose/_internal/task.py,sha256=XObr-fX9oH3TjgxHXQAUpKR2Zvup91uWSpfBeBbUJbU,6225
 goose/_internal/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 goose/_internal/types/agent.py,sha256=g0KD-aPWZlUGBx72AwQd3LeniFxHATeflZ7191QjFZA,2696
-goose_py-0.9.15.dist-info/METADATA,sha256=b87H2JP5nAIuYiit4wb_QXDK9JmZClQy9HlWjYZWRrA,442
-goose_py-0.9.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-goose_py-0.9.15.dist-info/RECORD,,
+goose/_internal/types/telemetry.py,sha256=7zeqyDDxf95puirNM6Gr9VFuxoDshXcV1__V0tiMswE,3663
+goose_py-0.10.0.dist-info/METADATA,sha256=ct-j5aAGBQsa1BNBKR00bj5zitPsNyPcjrDchAWqH54,442
+goose_py-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+goose_py-0.10.0.dist-info/RECORD,,