ModelEvent#

Implement the model contract and normalize usage and stream output. See the guide.

class zett_agent.model.ModelEvent(type, delta='', tool_call_delta=None, server_tool_call=None, server_tool_input_delta=None, server_tool_result=None, response=None)[source]#

One provider-neutral event emitted by an AgentModel.

        flowchart LR
    text[text deltas] --> response[one terminal ModelResponse]
    reasoning[reasoning deltas] --> response
    calls[tool-call JSON deltas] --> response
    response --> complete[complete message, usage, finish reason]

A successful model stream#

Examples

A minimal deterministic model can stream text and then return the same complete text in its terminal message:

async def stream(self, request):
    yield ModelEvent.text("Hello")
    yield ModelEvent.completed(
        ModelResponse(AssistantMessage(content="Hello"))
    )

Warning

Deltas are incremental display data. Do not append them as independent conversation messages, and do not omit the terminal response.

See also

AgentEvent is the higher-level stream consumed by applications after runtime lifecycle events are added.

Parameters:

type (ModelEventType)
delta (str)
tool_call_delta (ToolCallDelta | None)
server_tool_call (ServerToolCall | None)
server_tool_input_delta (ServerToolInputDelta | None)
server_tool_result (ServerToolResult | None)
response (ModelResponse | None)

type: ModelEventType#: Discriminator indicating which optional event field is populated.

delta: str#: Incremental answer or reasoning text for the corresponding delta type.

tool_call_delta: ToolCallDelta | None#: Partial tool identifier/name/arguments for TOOL_CALL_DELTA events.

server_tool_call: ServerToolCall | None#: Hosted invocation identity for a server-tool start event.

server_tool_input_delta: ServerToolInputDelta | None#: Hosted incremental input associated with an earlier start event.

server_tool_result: ServerToolResult | None#: Hosted terminal result for server-tool completion or failure events.

response: ModelResponse | None#: Complete final response, present only for RESPONSE events.

classmethod text(delta)[source]#

Create one answer-text fragment event.

Parameters:: delta (str)
Return type:: ModelEvent

classmethod reasoning(delta)[source]#

Create one provider-reported reasoning fragment event.

Parameters:: delta (str)
Return type:: ModelEvent

classmethod tool_call(delta)[source]#

Create one tool-call fragment event; this does not execute a tool.

Parameters:: delta (ToolCallDelta)
Return type:: ModelEvent

classmethod server_tool_started(call)[source]#

Expose the start of one provider-executed tool invocation.

Parameters:: call (ServerToolCall)
Return type:: ModelEvent

classmethod server_tool_input(delta)[source]#

Expose an incremental hosted-tool JSON input fragment.

Parameters:: delta (ServerToolInputDelta)
Return type:: ModelEvent

classmethod server_tool_completed(result)[source]#

Expose successful provider-side tool completion.

Parameters:: result (ServerToolResult)
Return type:: ModelEvent

classmethod server_tool_failed(result)[source]#

Expose provider-side tool failure without converting it to a transport error.

Parameters:: result (ServerToolResult)
Return type:: ModelEvent

classmethod completed(response)[source]#

Create the single terminal response event for a successful model call.

Parameters:: response (ModelResponse)
Return type:: ModelEvent