grasp_agents 0.5.5__py3-none-any.whl → 0.5.8__py3-none-any.whl

grasp_agents/typing/completion_chunk.py

@@ -15,7 +15,7 @@ from openai.types.chat.chat_completion_chunk import (
 from openai.types.chat.chat_completion_token_logprob import (
     ChatCompletionTokenLogprob as OpenAITokenLogprob,
 )
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ValidationError, field_validator
 
 from ..errors import CombineCompletionChunksError
 from .completion import Completion, CompletionChoice, FinishReason, Usage
@@ -38,13 +38,77 @@ class CompletionChunkDeltaToolCall(BaseModel):
 class CompletionChunkChoiceDelta(BaseModel):
     content: str | None = None
     refusal: str | None = None
-    role: Role | None
-    tool_calls: list[CompletionChunkDeltaToolCall] | None
+    role: Role | None = None
+    tool_calls: list[CompletionChunkDeltaToolCall] | None = None
     reasoning_content: str | None = None
     thinking_blocks: list[ThinkingBlock | RedactedThinkingBlock] | None = None
     annotations: list[LiteLLMAnnotation] | None = None
     provider_specific_fields: dict[str, Any] | None = None
 
+    @property
+    def thinking_delta(self) -> "CompletionChunkChoiceDelta | None":
+        return (
+            CompletionChunkChoiceDelta(
+                reasoning_content=self.reasoning_content,
+                thinking_blocks=self.thinking_blocks,
+                role=self.role,
+                provider_specific_fields=self.provider_specific_fields,
+            )
+            if self.reasoning_content or self.thinking_blocks
+            else None
+        )
+
+    @property
+    def tool_call_deltas(self) -> "list[CompletionChunkChoiceDelta] | None":
+        return (
+            [
+                CompletionChunkChoiceDelta(
+                    tool_calls=[tool_call],
+                    role=self.role,
+                    provider_specific_fields=self.provider_specific_fields,
+                )
+                for tool_call in self.tool_calls
+            ]
+            if self.tool_calls
+            else None
+        )
+
+    @property
+    def response_delta(self) -> "CompletionChunkChoiceDelta | None":
+        return (
+            CompletionChunkChoiceDelta(
+                content=self.content,
+                role=self.role,
+                provider_specific_fields=self.provider_specific_fields,
+            )
+            if self.content
+            else None
+        )
+
+    @property
+    def annotations_delta(self) -> "CompletionChunkChoiceDelta | None":
+        return (
+            CompletionChunkChoiceDelta(
+                annotations=self.annotations,
+                role=self.role,
+                provider_specific_fields=self.provider_specific_fields,
+            )
+            if self.annotations
+            else None
+        )
+
+    @property
+    def refusal_delta(self) -> "CompletionChunkChoiceDelta | None":
+        return (
+            CompletionChunkChoiceDelta(
+                refusal=self.refusal,
+                role=self.role,
+                provider_specific_fields=self.provider_specific_fields,
+            )
+            if self.refusal
+            else None
+        )
+
 
 class CompletionChunkChoice(BaseModel):
     delta: CompletionChunkChoiceDelta
@@ -66,6 +130,241 @@ class CompletionChunk(BaseModel):
     response_ms: float | None = None
     hidden_params: dict[str, Any] | None = None
 
+    def split_into_specialized(
+        self,
+    ) -> "list[CompletionChunk]":
+        if len(self.choices) != 1:
+            raise ValidationError(
+                "CompletionChunk must have exactly one choice for specialization."
+            )
+        delta = self.choices[0].delta
+
+        specialized_chunks: list[CompletionChunk] = []
+
+        thinking_delta = delta.thinking_delta
+        tool_call_deltas = delta.tool_call_deltas
+        response_delta = delta.response_delta
+        annotations_delta = delta.annotations_delta
+        refusal_delta = delta.refusal_delta
+
+        if thinking_delta is not None:
+            new_choice = self.choices[0].model_copy(update={"delta": thinking_delta})
+            new_chunk = self.model_copy(update={"choices": [new_choice]})
+            specialized_chunks.append(
+                ThinkingChunk.model_validate(new_chunk.model_dump())
+            )
+
+        if tool_call_deltas:
+            for delta_tool_call in tool_call_deltas:
+                new_choice = self.choices[0].model_copy(
+                    update={"delta": delta_tool_call}
+                )
+                new_chunk = self.model_copy(update={"choices": [new_choice]})
+                specialized_chunks.append(
+                    ToolCallChunk.model_validate(new_chunk.model_dump())
+                )
+
+        if response_delta is not None:
+            new_choice = self.choices[0].model_copy(update={"delta": response_delta})
+            new_chunk = self.model_copy(update={"choices": [new_choice]})
+            specialized_chunks.append(
+                ResponseChunk.model_validate(new_chunk.model_dump())
+            )
+
+        if annotations_delta is not None:
+            new_choice = self.choices[0].model_copy(update={"delta": annotations_delta})
+            new_chunk = self.model_copy(update={"choices": [new_choice]})
+            specialized_chunks.append(
+                AnnotationsChunk.model_validate(new_chunk.model_dump())
+            )
+
+        if refusal_delta is not None:
+            new_choice = self.choices[0].model_copy(update={"delta": refusal_delta})
+            new_chunk = self.model_copy(update={"choices": [new_choice]})
+            specialized_chunks.append(
+                RefusalChunk.model_validate(new_chunk.model_dump())
+            )
+
+        return specialized_chunks
+
+
+class ResponseChunk(CompletionChunk):
+    @field_validator("choices")
+    @classmethod
+    def validate_response_chunk(
+        cls, choices: list[CompletionChunkChoice]
+    ) -> list[CompletionChunkChoice]:
+        if len(choices) != 1:
+            raise ValidationError("ResponseChunk must have exactly one choice.")
+
+        delta = choices[0].delta
+
+        if not delta.content:
+            raise ValidationError("ResponseChunk must have content in deltas.")
+
+        if (
+            delta.reasoning_content is not None
+            or delta.thinking_blocks is not None
+            or delta.tool_calls is not None
+            or delta.refusal is not None
+            or delta.annotations is not None
+        ):
+            raise ValidationError(
+                "ResponseChunk should not have reasoning content, thinking blocks, "
+                "tool calls, refusal, or annotations in deltas."
+            )
+
+        return choices
+
+    @property
+    def response(self) -> str:
+        assert self.choices[0].delta.content
+        return self.choices[0].delta.content
+
+
+class ThinkingChunk(CompletionChunk):
+    @field_validator("choices")
+    @classmethod
+    def validate_thinking_chunk(
+        cls, choices: list[CompletionChunkChoice]
+    ) -> list[CompletionChunkChoice]:
+        if len(choices) != 1:
+            raise ValidationError("ThinkingChunk must have exactly one choice.")
+
+        delta = choices[0].delta
+
+        if not (delta.thinking_blocks or delta.reasoning_content):
+            raise ValidationError(
+                "ThinkingChunk must have reasoning content or "
+                "at least one thinking block."
+            )
+        if (
+            delta.content is not None
+            or delta.tool_calls is not None
+            or delta.refusal is not None
+            or delta.annotations is not None
+        ):
+            raise ValidationError(
+                "ThinkingChunk should not have content, tool calls, "
+                "refusal, or annotations in deltas."
+            )
+
+        return choices
+
+    @property
+    def thinking(self) -> str | list[ThinkingBlock | RedactedThinkingBlock]:
+        delta = self.choices[0].delta
+        if delta.reasoning_content:
+            return delta.reasoning_content
+        if delta.thinking_blocks:
+            return delta.thinking_blocks
+        raise ValueError("ThinkingChunk has no reasoning_content or thinking_blocks")
+
+
+class ToolCallChunk(CompletionChunk):
+    @field_validator("choices")
+    @classmethod
+    def validate_tool_call_chunk(
+        cls, choices: list[CompletionChunkChoice]
+    ) -> list[CompletionChunkChoice]:
+        if len(choices) != 1:
+            raise ValidationError("ToolCallChunk must have exactly one choice.")
+
+        delta = choices[0].delta
+
+        if not delta.tool_calls:
+            raise ValidationError("ToolCallChunk must have tool calls in deltas.")
+        if len(delta.tool_calls) != 1:
+            raise ValidationError(
+                "ToolCallChunk must have exactly one tool call in deltas."
+            )
+
+        if (
+            delta.reasoning_content is not None
+            or delta.thinking_blocks is not None
+            or delta.content is not None
+            or delta.refusal is not None
+            or delta.annotations is not None
+        ):
+            raise ValidationError(
+                "ToolCallChunk should not have reasoning content, thinking blocks, "
+                "content, refusal, or annotations in deltas."
+            )
+
+        return choices
+
+    @property
+    def tool_call(self) -> CompletionChunkDeltaToolCall:
+        assert self.choices[0].delta.tool_calls is not None
+        return self.choices[0].delta.tool_calls[0]
+
+
+class AnnotationsChunk(CompletionChunk):
+    @field_validator("choices")
+    @classmethod
+    def validate_annotations_chunk(
+        cls, choices: list[CompletionChunkChoice]
+    ) -> list[CompletionChunkChoice]:
+        if len(choices) != 1:
+            raise ValidationError("AnnotationsChunk must have exactly one choice.")
+
+        delta = choices[0].delta
+
+        if not delta.annotations:
+            raise ValidationError("AnnotationsChunk must have annotations in deltas.")
+
+        if (
+            delta.reasoning_content is not None
+            or delta.thinking_blocks is not None
+            or delta.content is not None
+            or delta.tool_calls is not None
+            or delta.refusal is not None
+        ):
+            raise ValidationError(
+                "AnnotationsChunk should not have reasoning content, thinking blocks, "
+                "content, tool calls, or refusal in deltas."
+            )
+
+        return choices
+
+    @property
+    def annotations(self) -> list[LiteLLMAnnotation]:
+        assert self.choices[0].delta.annotations is not None
+        return self.choices[0].delta.annotations
+
+
+class RefusalChunk(CompletionChunk):
+    @field_validator("choices")
+    @classmethod
+    def validate_refusal_chunk(
+        cls, choices: list[CompletionChunkChoice]
+    ) -> list[CompletionChunkChoice]:
+        if len(choices) != 1:
+            raise ValidationError("RefusalChunk must have exactly one choice.")
+
+        delta = choices[0].delta
+
+        if not delta.refusal:
+            raise ValidationError("RefusalChunk must have refusal in deltas.")
+
+        if (
+            delta.reasoning_content is not None
+            or delta.thinking_blocks is not None
+            or delta.content is not None
+            or delta.tool_calls is not None
+            or delta.annotations is not None
+        ):
+            raise ValidationError(
+                "RefusalChunk should not have reasoning content, thinking blocks, "
+                "content, tool calls, or annotations in deltas."
+            )
+
+        return choices
+
+    @property
+    def refusal(self) -> str | None:
+        return self.choices[0].delta.refusal
+
 
 def combine_completion_chunks(chunks: list[CompletionChunk]) -> Completion:
     if not chunks:

grasp_agents/typing/events.py

@@ -1,14 +1,28 @@
 import time
 from enum import StrEnum
-from typing import Any, Generic, Literal, TypeVar
+from typing import Any, Generic, Literal, TypeVar, get_args
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
 
 from ..packet import Packet
 from .completion import Completion
-from .completion_chunk import CompletionChunk
-from .message import AssistantMessage, SystemMessage, ToolCall, ToolMessage, UserMessage
+from .completion_chunk import (
+    AnnotationsChunk,
+    CompletionChunk,
+    RefusalChunk,
+    ResponseChunk,
+    ThinkingChunk,
+    ToolCallChunk,
+)
+from .message import (
+    AssistantMessage,
+    MessageBase,
+    SystemMessage,
+    ToolCall,
+    ToolMessage,
+    UserMessage,
+)
 
 
 class EventSourceType(StrEnum):
@@ -29,69 +43,68 @@ class EventType(StrEnum):
     GEN_MSG = "gen_message"
 
     COMP = "completion"
+    COMP_START = "completion_start"
+    COMP_END = "completion_end"
+
     COMP_CHUNK = "completion_chunk"
+    THINK_CHUNK = "thinking_chunk"
+    RESP_CHUNK = "response_chunk"
+    TOOL_CALL_CHUNK = "tool_call_chunk"
+    ANNOT_CHUNK = "annotations_chunk"
+    REFUSAL_CHUNK = "refusal_chunk"
+
+    RESP_START = "response_start"
+    RESP_END = "response_end"
+    THINK_START = "thinking_start"
+    THINK_END = "thinking_end"
+    TOOL_CALL_START = "tool_call_start"
+    TOOL_CALL_END = "tool_call_end"
+    ANNOT_START = "annotations_start"
+    ANNOT_END = "annotations_end"
+
     LLM_ERR = "llm_error"
 
-    PROC_START = "processor_start"
     PACKET_OUT = "packet_output"
     PAYLOAD_OUT = "payload_output"
     PROC_FINISH = "processor_finish"
     PROC_ERR = "processor_error"
+    PROC_START = "processor_start"
+    PROC_END = "processor_end"
 
     WORKFLOW_RES = "workflow_result"
     RUN_RES = "run_result"
 
-    # COMP_THINK_CHUNK = "completion_thinking_chunk"
-    # COMP_RESP_CHUNK = "completion_response_chunk"
 
+_T_co = TypeVar("_T_co", covariant=True)
+_M_co = TypeVar("_M_co", covariant=True, bound=MessageBase)
+_C_co = TypeVar("_C_co", covariant=True, bound=CompletionChunk)
 
-_T = TypeVar("_T")
 
-
-class Event(BaseModel, Generic[_T], frozen=True):
+class Event(BaseModel, Generic[_T_co], frozen=True):
     type: EventType
     source: EventSourceType
     id: str = Field(default_factory=lambda: str(uuid4()))
     created: int = Field(default_factory=lambda: int(time.time()))
     proc_name: str | None = None
     call_id: str | None = None
-    data: _T
+    data: _T_co
 
 
-class CompletionEvent(Event[Completion], frozen=True):
-    type: Literal[EventType.COMP] = EventType.COMP
-    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+class DummyEvent(Event[Any], frozen=True):
+    type: Literal[EventType.PAYLOAD_OUT] = EventType.PAYLOAD_OUT
+    source: Literal[EventSourceType.PROC] = EventSourceType.PROC
+    data: Any = None
 
 
-class CompletionChunkEvent(Event[CompletionChunk], frozen=True):
-    type: Literal[EventType.COMP_CHUNK] = EventType.COMP_CHUNK
-    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+# Non-streamed completion events
 
 
-class LLMStreamingErrorData(BaseModel):
-    error: Exception
-    model_name: str | None = None
-    model_id: str | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class LLMStreamingErrorEvent(Event[LLMStreamingErrorData], frozen=True):
-    type: Literal[EventType.LLM_ERR] = EventType.LLM_ERR
+class CompletionEvent(Event[Completion], frozen=True):
+    type: Literal[EventType.COMP] = EventType.COMP
     source: Literal[EventSourceType.LLM] = EventSourceType.LLM
 
 
-# class CompletionThinkingChunkEvent(Event[CompletionChunk], frozen=True):
-#     type: Literal[EventType.COMP_THINK_CHUNK] = EventType.COMP_THINK_CHUNK
-#     source: Literal[EventSourceType.LLM] = EventSourceType.LLM
-
-
-# class CompletionResponseChunkEvent(Event[CompletionChunk], frozen=True):
-#     type: Literal[EventType.COMP_RESP_CHUNK] = EventType.COMP_RESP_CHUNK
-#     source: Literal[EventSourceType.LLM] = EventSourceType.LLM
-
-
-class MessageEvent(Event[_T], Generic[_T], frozen=True):
+class MessageEvent(Event[_M_co], Generic[_M_co], frozen=True):
     pass
 
 
@@ -120,13 +133,207 @@ class ToolCallEvent(Event[ToolCall], frozen=True):
     source: Literal[EventSourceType.AGENT] = EventSourceType.AGENT
 
 
+# Streamed completion events
+
+StreamedCompletionEventTypes = Literal[
+    EventType.COMP_CHUNK,
+    EventType.COMP_START,
+    EventType.COMP_END,
+    EventType.RESP_CHUNK,
+    EventType.RESP_START,
+    EventType.RESP_END,
+    EventType.THINK_CHUNK,
+    EventType.THINK_START,
+    EventType.THINK_END,
+    EventType.TOOL_CALL_CHUNK,
+    EventType.TOOL_CALL_START,
+    EventType.TOOL_CALL_END,
+    EventType.ANNOT_CHUNK,
+    EventType.ANNOT_START,
+    EventType.ANNOT_END,
+    EventType.REFUSAL_CHUNK,
+]
+
+
+class CompletionChunkEvent(Event[_C_co], Generic[_C_co], frozen=True):
+    type: StreamedCompletionEventTypes = EventType.COMP_CHUNK
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    data: _C_co
+
+    def split_into_specialized(
+        self,
+    ) -> "list[CompletionChunkEvent[Any]]":
+        specialized_events: list[CompletionChunkEvent[Any]] = []
+
+        for sub_chunk in self.data.split_into_specialized():
+            if isinstance(sub_chunk, ResponseChunk):
+                new_event = self.model_copy(
+                    update={"data": sub_chunk, "type": EventType.RESP_CHUNK}
+                )
+                specialized_events.append(
+                    ResponseChunkEvent.model_validate(new_event.model_dump())
+                )
+            if isinstance(sub_chunk, ThinkingChunk):
+                new_event = self.model_copy(
+                    update={"data": sub_chunk, "type": EventType.THINK_CHUNK}
+                )
+                specialized_events.append(
+                    ThinkingChunkEvent.model_validate(new_event.model_dump())
+                )
+            if isinstance(sub_chunk, ToolCallChunk):
+                new_event = self.model_copy(
+                    update={"data": sub_chunk, "type": EventType.TOOL_CALL_CHUNK}
+                )
+                specialized_events.append(
+                    ToolCallChunkEvent.model_validate(new_event.model_dump())
+                )
+            if isinstance(sub_chunk, AnnotationsChunk):
+                new_event = self.model_copy(
+                    update={"data": sub_chunk, "type": EventType.ANNOT_CHUNK}
+                )
+                specialized_events.append(
+                    AnnotationsChunkEvent.model_validate(new_event.model_dump())
+                )
+            if isinstance(sub_chunk, RefusalChunk):
+                new_event = self.model_copy(
+                    update={"data": sub_chunk, "type": EventType.REFUSAL_CHUNK}
+                )
+                specialized_events.append(
+                    RefusalChunkEvent.model_validate(new_event.model_dump())
+                )
+
+        return specialized_events
+
+
+class ResponseChunkEvent(CompletionChunkEvent[ResponseChunk], frozen=True):
+    type: Literal[EventType.RESP_CHUNK] = EventType.RESP_CHUNK
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+
+
+class ThinkingChunkEvent(CompletionChunkEvent[ThinkingChunk], frozen=True):
+    type: Literal[EventType.THINK_CHUNK] = EventType.THINK_CHUNK
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+
+
+class ToolCallChunkEvent(CompletionChunkEvent[ToolCallChunk], frozen=True):
+    type: Literal[EventType.TOOL_CALL_CHUNK] = EventType.TOOL_CALL_CHUNK
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+
+
+class AnnotationsChunkEvent(CompletionChunkEvent[AnnotationsChunk], frozen=True):
+    type: Literal[EventType.ANNOT_CHUNK] = EventType.ANNOT_CHUNK
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+
+
+class RefusalChunkEvent(CompletionChunkEvent[RefusalChunk], frozen=True):
+    type: Literal[EventType.REFUSAL_CHUNK] = EventType.REFUSAL_CHUNK
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+
+
+START_END_MAP: dict[EventType, list[EventType]] = {
+    EventType.COMP_CHUNK: [EventType.COMP_START, EventType.COMP_END],
+    EventType.RESP_CHUNK: [EventType.RESP_START, EventType.RESP_END],
+    EventType.THINK_CHUNK: [EventType.THINK_START, EventType.THINK_END],
+    EventType.TOOL_CALL_CHUNK: [EventType.TOOL_CALL_START, EventType.TOOL_CALL_END],
+    EventType.ANNOT_CHUNK: [EventType.ANNOT_START, EventType.ANNOT_END],
+}
+
+
+class LLMStateChangeEvent(CompletionChunkEvent[_C_co], Generic[_C_co], frozen=True):
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: bool = True
+
+    @classmethod
+    def from_chunk_event(
+        cls, event: CompletionChunkEvent[CompletionChunk]
+    ) -> "LLMStateChangeEvent[_C_co]":
+        _type = get_args(cls.model_fields["type"].annotation)[0]
+        return cls(**event.model_copy(update={"type": _type}).model_dump())
+
+
+class CompletionStartEvent(LLMStateChangeEvent[CompletionChunk], frozen=True):
+    type: Literal[EventType.COMP_START] = EventType.COMP_START
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[True] = True
+
+
+class CompletionEndEvent(LLMStateChangeEvent[CompletionChunk], frozen=True):
+    type: Literal[EventType.COMP_END] = EventType.COMP_END
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[False] = False
+
+
+class ResponseStartEvent(LLMStateChangeEvent[ResponseChunk], frozen=True):
+    type: Literal[EventType.RESP_START] = EventType.RESP_START
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[True] = True
+
+
+class ResponseEndEvent(LLMStateChangeEvent[ResponseChunk], frozen=True):
+    type: Literal[EventType.RESP_END] = EventType.RESP_END
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[False] = False
+
+
+class ThinkingStartEvent(LLMStateChangeEvent[ThinkingChunk], frozen=True):
+    type: Literal[EventType.THINK_START] = EventType.THINK_START
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[True] = True
+
+
+class ThinkingEndEvent(LLMStateChangeEvent[ThinkingChunk], frozen=True):
+    type: Literal[EventType.THINK_END] = EventType.THINK_END
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[False] = False
+
+
+class ToolCallStartEvent(LLMStateChangeEvent[ToolCallChunk], frozen=True):
+    type: Literal[EventType.TOOL_CALL_START] = EventType.TOOL_CALL_START
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[True] = True
+
+
+class ToolCallEndEvent(LLMStateChangeEvent[ToolCallChunk], frozen=True):
+    type: Literal[EventType.TOOL_CALL_END] = EventType.TOOL_CALL_END
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[False] = False
+
+
+class AnnotationsStartEvent(LLMStateChangeEvent[AnnotationsChunk], frozen=True):
+    type: Literal[EventType.ANNOT_START] = EventType.ANNOT_START
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[True] = True
+
+
+class AnnotationsEndEvent(LLMStateChangeEvent[AnnotationsChunk], frozen=True):
+    type: Literal[EventType.ANNOT_END] = EventType.ANNOT_END
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+    start: Literal[False] = False
+
+
+class LLMStreamingErrorData(BaseModel):
+    error: Exception
+    model_name: str | None = None
+    model_id: str | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class LLMStreamingErrorEvent(Event[LLMStreamingErrorData], frozen=True):
+    type: Literal[EventType.LLM_ERR] = EventType.LLM_ERR
+    source: Literal[EventSourceType.LLM] = EventSourceType.LLM
+
+
+# Processor events
+
+
 class ProcStartEvent(Event[None], frozen=True):
     type: Literal[EventType.PROC_START] = EventType.PROC_START
     source: Literal[EventSourceType.PROC] = EventSourceType.PROC
 
 
-class ProcFinishEvent(Event[None], frozen=True):
-    type: Literal[EventType.PROC_FINISH] = EventType.PROC_FINISH
+class ProcEndEvent(Event[None], frozen=True):
+    type: Literal[EventType.PROC_END] = EventType.PROC_END
     source: Literal[EventSourceType.PROC] = EventSourceType.PROC
 
 
@@ -144,16 +351,6 @@ class ProcPacketOutputEvent(Event[Packet[Any]], frozen=True):
     ] = EventSourceType.PROC
 
 
-class WorkflowResultEvent(ProcPacketOutputEvent, frozen=True):
-    type: Literal[EventType.WORKFLOW_RES] = EventType.WORKFLOW_RES
-    source: Literal[EventSourceType.WORKFLOW] = EventSourceType.WORKFLOW
-
-
-class RunResultEvent(ProcPacketOutputEvent, frozen=True):
-    type: Literal[EventType.RUN_RES] = EventType.RUN_RES
-    source: Literal[EventSourceType.RUN] = EventSourceType.RUN
-
-
 class ProcStreamingErrorData(BaseModel):
     error: Exception
     call_id: str | None = None
@@ -164,3 +361,16 @@ class ProcStreamingErrorData(BaseModel):
 class ProcStreamingErrorEvent(Event[ProcStreamingErrorData], frozen=True):
     type: Literal[EventType.PROC_ERR] = EventType.PROC_ERR
     source: Literal[EventSourceType.PROC] = EventSourceType.PROC
+
+
+# Workflow and run events
+
+
+class WorkflowResultEvent(ProcPacketOutputEvent, frozen=True):
+    type: Literal[EventType.WORKFLOW_RES] = EventType.WORKFLOW_RES
+    source: Literal[EventSourceType.WORKFLOW] = EventSourceType.WORKFLOW
+
+
+class RunResultEvent(ProcPacketOutputEvent, frozen=True):
+    type: Literal[EventType.RUN_RES] = EventType.RUN_RES
+    source: Literal[EventSourceType.RUN] = EventSourceType.RUN