featherweight 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- featherweight/__init__.py +216 -0
- featherweight/adapters/__init__.py +10 -0
- featherweight/adapters/agui.py +61 -0
- featherweight/adapters/errors.py +5 -0
- featherweight/adapters/vercel.py +245 -0
- featherweight/background.py +178 -0
- featherweight/client.py +161 -0
- featherweight/context.py +34 -0
- featherweight/db.py +372 -0
- featherweight/discovery.py +102 -0
- featherweight/errors.py +10 -0
- featherweight/events.py +156 -0
- featherweight/fingerprint.py +125 -0
- featherweight/jobs.py +430 -0
- featherweight/log.py +23 -0
- featherweight/mcp.py +113 -0
- featherweight/mcp_connections.py +239 -0
- featherweight/mcp_tools.py +132 -0
- featherweight/messages.py +144 -0
- featherweight/migrations.py +201 -0
- featherweight/model_settings.py +223 -0
- featherweight/models.py +330 -0
- featherweight/observers.py +459 -0
- featherweight/otel.py +397 -0
- featherweight/postgres.py +488 -0
- featherweight/py.typed +0 -0
- featherweight/queue.py +217 -0
- featherweight/registry.py +100 -0
- featherweight/results.py +79 -0
- featherweight/runner.py +1488 -0
- featherweight/search.py +48 -0
- featherweight/skills.py +153 -0
- featherweight/sqlite.py +526 -0
- featherweight/sse.py +67 -0
- featherweight/store.py +34 -0
- featherweight/stream_events.py +270 -0
- featherweight/streaming.py +132 -0
- featherweight/testing.py +884 -0
- featherweight/tools.py +176 -0
- featherweight/worker.py +339 -0
- featherweight-0.1.0.dist-info/METADATA +155 -0
- featherweight-0.1.0.dist-info/RECORD +45 -0
- featherweight-0.1.0.dist-info/WHEEL +5 -0
- featherweight-0.1.0.dist-info/licenses/LICENSE +202 -0
- featherweight-0.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,216 @@
|
|
|
1
|
+
"""featherweight: an opinionated agent harness. Pydantic is the spec.
|
|
2
|
+
|
|
3
|
+
from featherweight import AgentBase, AgentRunner
|
|
4
|
+
|
|
5
|
+
class Summariser(AgentBase): ...
|
|
6
|
+
runner = AgentRunner(db)
|
|
7
|
+
|
|
8
|
+
The public names are available on the package. Each is loaded when it is first used, so that `import featherweight` stays
|
|
9
|
+
light and imports no model provider. The modules are there too (`featherweight.model_settings`, ...), and the two adapters are `featherweight.adapters.agui` and `featherweight.adapters.vercel`.
|
|
10
|
+
"""
|
|
11
|
+
|
|
12
|
+
import importlib
|
|
13
|
+
from typing import TYPE_CHECKING, Any
|
|
14
|
+
|
|
15
|
+
__version__ = "0.1.0" # x-release-please-version
|
|
16
|
+
|
|
17
|
+
# The public API: name -> the module that defines it.
|
|
18
|
+
_EXPORTS = {
|
|
19
|
+
# agents and results
|
|
20
|
+
"AgentBase": "models",
|
|
21
|
+
"AgentInput": "models",
|
|
22
|
+
"AgentOutput": "models",
|
|
23
|
+
"AgentResult": "models",
|
|
24
|
+
"RunStatus": "models",
|
|
25
|
+
"AgentRunner": "runner",
|
|
26
|
+
# streaming agents
|
|
27
|
+
"StreamingAgent": "streaming",
|
|
28
|
+
"StreamingRun": "streaming",
|
|
29
|
+
"ChatInput": "streaming",
|
|
30
|
+
"to_langchain": "messages",
|
|
31
|
+
"to_agui": "messages",
|
|
32
|
+
# models
|
|
33
|
+
"ModelSettings": "model_settings",
|
|
34
|
+
"ModelInfo": "model_settings",
|
|
35
|
+
"Gemini": "model_settings",
|
|
36
|
+
"Gemma": "model_settings",
|
|
37
|
+
"Claude": "model_settings",
|
|
38
|
+
"OpenAI": "model_settings",
|
|
39
|
+
# the run log and jobs
|
|
40
|
+
"Database": "db",
|
|
41
|
+
"SqliteDatabase": "sqlite",
|
|
42
|
+
"PostgresDatabase": "postgres",
|
|
43
|
+
"RunStart": "db",
|
|
44
|
+
"RunEnd": "db",
|
|
45
|
+
"JobRow": "db",
|
|
46
|
+
"JobOwner": "db",
|
|
47
|
+
"JobLost": "db",
|
|
48
|
+
"AgentRunRow": "db",
|
|
49
|
+
"JobEvent": "db",
|
|
50
|
+
"job_events": "events",
|
|
51
|
+
"wait_for_job": "events",
|
|
52
|
+
"default_db_path": "db",
|
|
53
|
+
"run_job": "jobs",
|
|
54
|
+
"JobWorker": "worker",
|
|
55
|
+
# observers
|
|
56
|
+
"Observer": "observers",
|
|
57
|
+
"Scope": "observers",
|
|
58
|
+
"JobStart": "observers",
|
|
59
|
+
"JobEnd": "observers",
|
|
60
|
+
"JobSubmitted": "observers",
|
|
61
|
+
"AttemptStart": "observers",
|
|
62
|
+
"AttemptEnd": "observers",
|
|
63
|
+
"ReusedRun": "observers",
|
|
64
|
+
"ModelCallStart": "observers",
|
|
65
|
+
"ModelCallEnd": "observers",
|
|
66
|
+
"ToolCallStart": "observers",
|
|
67
|
+
"ToolCallEnd": "observers",
|
|
68
|
+
"OTelObserver": "otel",
|
|
69
|
+
"JobOutcome": "jobs",
|
|
70
|
+
"Job": "jobs",
|
|
71
|
+
"JobClient": "client",
|
|
72
|
+
"job": "jobs",
|
|
73
|
+
"JobContext": "jobs",
|
|
74
|
+
"JobTimeout": "jobs",
|
|
75
|
+
"as_job": "jobs",
|
|
76
|
+
# what an agent can have, and what a tool can use
|
|
77
|
+
"Skill": "skills",
|
|
78
|
+
"StdioMCPServer": "mcp",
|
|
79
|
+
"HttpMCPServer": "mcp",
|
|
80
|
+
"RunStore": "store",
|
|
81
|
+
"ResultStore": "results",
|
|
82
|
+
"ResultKey": "results",
|
|
83
|
+
"SqliteResultStore": "results",
|
|
84
|
+
"JobQueue": "queue",
|
|
85
|
+
"JobMessage": "queue",
|
|
86
|
+
"Delivery": "queue",
|
|
87
|
+
"SqliteQueue": "queue",
|
|
88
|
+
"RunContext": "context",
|
|
89
|
+
"SetupError": "errors",
|
|
90
|
+
"BadRequest": "adapters.errors",
|
|
91
|
+
"setup_logging": "log",
|
|
92
|
+
}
|
|
93
|
+
_SUBMODULES = {
|
|
94
|
+
"agui": "adapters.agui",
|
|
95
|
+
"vercel": "adapters.vercel",
|
|
96
|
+
"sse": "sse",
|
|
97
|
+
} # the two adapters, as `featherweight.agui` and `featherweight.vercel`
|
|
98
|
+
_MODULES = (
|
|
99
|
+
"adapters",
|
|
100
|
+
"client",
|
|
101
|
+
"context",
|
|
102
|
+
"db",
|
|
103
|
+
"errors",
|
|
104
|
+
"events",
|
|
105
|
+
"jobs",
|
|
106
|
+
"log",
|
|
107
|
+
"mcp",
|
|
108
|
+
"messages",
|
|
109
|
+
"model_settings",
|
|
110
|
+
"models",
|
|
111
|
+
"postgres",
|
|
112
|
+
"queue",
|
|
113
|
+
"registry",
|
|
114
|
+
"results",
|
|
115
|
+
"runner",
|
|
116
|
+
"skills",
|
|
117
|
+
"sqlite",
|
|
118
|
+
"store",
|
|
119
|
+
"streaming",
|
|
120
|
+
"testing",
|
|
121
|
+
"tools",
|
|
122
|
+
"worker",
|
|
123
|
+
)
|
|
124
|
+
|
|
125
|
+
__all__ = ["__version__", *_EXPORTS, *_SUBMODULES]
|
|
126
|
+
|
|
127
|
+
if TYPE_CHECKING: # for editors and type checkers: the same names, imported
|
|
128
|
+
from featherweight import adapters as adapters
|
|
129
|
+
from featherweight import sse as sse
|
|
130
|
+
from featherweight.adapters import agui as agui
|
|
131
|
+
from featherweight.adapters import vercel as vercel
|
|
132
|
+
from featherweight.adapters.errors import BadRequest as BadRequest
|
|
133
|
+
from featherweight.client import JobClient as JobClient
|
|
134
|
+
from featherweight.context import RunContext as RunContext
|
|
135
|
+
from featherweight.db import AgentRunRow as AgentRunRow
|
|
136
|
+
from featherweight.db import Database as Database
|
|
137
|
+
from featherweight.db import JobEvent as JobEvent
|
|
138
|
+
from featherweight.db import JobLost as JobLost
|
|
139
|
+
from featherweight.db import JobOwner as JobOwner
|
|
140
|
+
from featherweight.db import JobRow as JobRow
|
|
141
|
+
from featherweight.db import RunEnd as RunEnd
|
|
142
|
+
from featherweight.db import RunStart as RunStart
|
|
143
|
+
from featherweight.db import default_db_path as default_db_path
|
|
144
|
+
from featherweight.errors import SetupError as SetupError
|
|
145
|
+
from featherweight.events import job_events as job_events
|
|
146
|
+
from featherweight.events import wait_for_job as wait_for_job
|
|
147
|
+
from featherweight.jobs import Job as Job
|
|
148
|
+
from featherweight.jobs import JobContext as JobContext
|
|
149
|
+
from featherweight.jobs import JobOutcome as JobOutcome
|
|
150
|
+
from featherweight.jobs import JobTimeout as JobTimeout
|
|
151
|
+
from featherweight.jobs import as_job as as_job
|
|
152
|
+
from featherweight.jobs import job as job
|
|
153
|
+
from featherweight.jobs import run_job as run_job
|
|
154
|
+
from featherweight.log import setup_logging as setup_logging
|
|
155
|
+
from featherweight.mcp import HttpMCPServer as HttpMCPServer
|
|
156
|
+
from featherweight.mcp import StdioMCPServer as StdioMCPServer
|
|
157
|
+
from featherweight.messages import to_agui as to_agui
|
|
158
|
+
from featherweight.messages import to_langchain as to_langchain
|
|
159
|
+
from featherweight.model_settings import Claude as Claude
|
|
160
|
+
from featherweight.model_settings import Gemini as Gemini
|
|
161
|
+
from featherweight.model_settings import Gemma as Gemma
|
|
162
|
+
from featherweight.model_settings import ModelInfo as ModelInfo
|
|
163
|
+
from featherweight.model_settings import ModelSettings as ModelSettings
|
|
164
|
+
from featherweight.model_settings import OpenAI as OpenAI
|
|
165
|
+
from featherweight.models import AgentBase as AgentBase
|
|
166
|
+
from featherweight.models import AgentInput as AgentInput
|
|
167
|
+
from featherweight.models import AgentOutput as AgentOutput
|
|
168
|
+
from featherweight.models import AgentResult as AgentResult
|
|
169
|
+
from featherweight.models import RunStatus as RunStatus
|
|
170
|
+
from featherweight.observers import AttemptEnd as AttemptEnd
|
|
171
|
+
from featherweight.observers import AttemptStart as AttemptStart
|
|
172
|
+
from featherweight.observers import JobEnd as JobEnd
|
|
173
|
+
from featherweight.observers import JobStart as JobStart
|
|
174
|
+
from featherweight.observers import JobSubmitted as JobSubmitted
|
|
175
|
+
from featherweight.observers import ModelCallEnd as ModelCallEnd
|
|
176
|
+
from featherweight.observers import ModelCallStart as ModelCallStart
|
|
177
|
+
from featherweight.observers import Observer as Observer
|
|
178
|
+
from featherweight.observers import ReusedRun as ReusedRun
|
|
179
|
+
from featherweight.observers import Scope as Scope
|
|
180
|
+
from featherweight.observers import ToolCallEnd as ToolCallEnd
|
|
181
|
+
from featherweight.observers import ToolCallStart as ToolCallStart
|
|
182
|
+
from featherweight.otel import OTelObserver as OTelObserver
|
|
183
|
+
from featherweight.postgres import PostgresDatabase as PostgresDatabase
|
|
184
|
+
from featherweight.queue import Delivery as Delivery
|
|
185
|
+
from featherweight.queue import JobMessage as JobMessage
|
|
186
|
+
from featherweight.queue import JobQueue as JobQueue
|
|
187
|
+
from featherweight.queue import SqliteQueue as SqliteQueue
|
|
188
|
+
from featherweight.results import ResultKey as ResultKey
|
|
189
|
+
from featherweight.results import ResultStore as ResultStore
|
|
190
|
+
from featherweight.results import SqliteResultStore as SqliteResultStore
|
|
191
|
+
from featherweight.runner import AgentRunner as AgentRunner
|
|
192
|
+
from featherweight.skills import Skill as Skill
|
|
193
|
+
from featherweight.sqlite import SqliteDatabase as SqliteDatabase
|
|
194
|
+
from featherweight.store import RunStore as RunStore
|
|
195
|
+
from featherweight.streaming import ChatInput as ChatInput
|
|
196
|
+
from featherweight.streaming import StreamingAgent as StreamingAgent
|
|
197
|
+
from featherweight.streaming import StreamingRun as StreamingRun
|
|
198
|
+
from featherweight.worker import JobWorker as JobWorker
|
|
199
|
+
|
|
200
|
+
|
|
201
|
+
def __getattr__(name: str) -> Any:
|
|
202
|
+
module = _EXPORTS.get(name)
|
|
203
|
+
if module is not None:
|
|
204
|
+
value = getattr(importlib.import_module(f"featherweight.{module}"), name)
|
|
205
|
+
elif name in _SUBMODULES:
|
|
206
|
+
value = importlib.import_module(f"featherweight.{_SUBMODULES[name]}")
|
|
207
|
+
elif name in _MODULES:
|
|
208
|
+
value = importlib.import_module(f"featherweight.{name}")
|
|
209
|
+
else:
|
|
210
|
+
raise AttributeError(f"module 'featherweight' has no attribute {name!r}")
|
|
211
|
+
globals()[name] = value # found once, then a plain attribute
|
|
212
|
+
return value
|
|
213
|
+
|
|
214
|
+
|
|
215
|
+
def __dir__() -> list[str]:
|
|
216
|
+
return sorted({*globals(), *_EXPORTS, *_SUBMODULES, *_MODULES})
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
"""Adapters between a streaming run and a wire format: read a client's request, encode the events.
|
|
2
|
+
|
|
3
|
+
agui.encode(run) vercel.encode(run)
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
from featherweight.adapters.errors import BadRequest
|
|
7
|
+
|
|
8
|
+
from featherweight.adapters import agui, vercel # isort: skip
|
|
9
|
+
|
|
10
|
+
__all__ = ["BadRequest", "agui", "vercel"]
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
"""The AG-UI adapter. The events of a streaming run already are AG-UI's, so this is only the edge with HTTP: read a
|
|
2
|
+
request into a `ChatInput`, and encode the events of a run as server-sent events. No server and no web framework."""
|
|
3
|
+
|
|
4
|
+
import json
|
|
5
|
+
import logging
|
|
6
|
+
from collections.abc import AsyncGenerator
|
|
7
|
+
from typing import Any
|
|
8
|
+
|
|
9
|
+
from ag_ui.core import RunAgentInput
|
|
10
|
+
from ag_ui.encoder import EventEncoder
|
|
11
|
+
from pydantic import ValidationError
|
|
12
|
+
|
|
13
|
+
from featherweight.adapters.errors import BadRequest
|
|
14
|
+
from featherweight.streaming import ChatInput, StreamingRun
|
|
15
|
+
|
|
16
|
+
logger = logging.getLogger(__name__)
|
|
17
|
+
|
|
18
|
+
CONTENT_TYPE = "text/event-stream"
|
|
19
|
+
# Headers for the response: the stream must not be cached or buffered on its way to the browser.
|
|
20
|
+
HEADERS = {"Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"}
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
def _problems(exc: ValidationError) -> str:
|
|
24
|
+
return "; ".join(f"{'.'.join(str(p) for p in e['loc']) or 'body'}: {e['msg']}" for e in exc.errors())
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
def parse_request(body: dict[str, Any] | bytes | str) -> ChatInput:
|
|
28
|
+
"""The JSON body of an AG-UI request (a `RunAgentInput`) as a `ChatInput`.
|
|
29
|
+
|
|
30
|
+
`threadId` is kept. The client's `tools`, `state`, `context` and `forwardedProps` are ignored: the agent has its own
|
|
31
|
+
tools, and a warning is logged when tools are sent. Raises `BadRequest` (a `ValueError`) for a body that is not JSON,
|
|
32
|
+
is not a `RunAgentInput`, or is a conversation a `ChatInput` refuses (a `system` or `developer` message, a last
|
|
33
|
+
message that is not the user's).
|
|
34
|
+
"""
|
|
35
|
+
try:
|
|
36
|
+
data = json.loads(body) if isinstance(body, bytes | str) else body
|
|
37
|
+
request = RunAgentInput.model_validate(data)
|
|
38
|
+
except json.JSONDecodeError as exc:
|
|
39
|
+
raise BadRequest(f"The body is not JSON: {exc}") from exc
|
|
40
|
+
except ValidationError as exc:
|
|
41
|
+
raise BadRequest(f"The body is not an AG-UI request: {_problems(exc)}") from exc
|
|
42
|
+
if request.tools:
|
|
43
|
+
logger.warning("agui_tools_ignored count=%d: the agent has its own tools", len(request.tools))
|
|
44
|
+
try:
|
|
45
|
+
return ChatInput(messages=request.messages, thread_id=request.thread_id)
|
|
46
|
+
except ValidationError as exc:
|
|
47
|
+
raise BadRequest(f"The conversation is not valid: {_problems(exc)}") from exc
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
async def encode(run: StreamingRun) -> AsyncGenerator[str, None]:
|
|
51
|
+
"""The events of `run` as server-sent events, one string each (`data: {...}` and a blank line), for the body of a
|
|
52
|
+
streaming response. Leaving the loop early stops the run."""
|
|
53
|
+
encoder = EventEncoder()
|
|
54
|
+
events = aiter(run)
|
|
55
|
+
try:
|
|
56
|
+
async for event in events:
|
|
57
|
+
yield encoder.encode(event)
|
|
58
|
+
finally:
|
|
59
|
+
close = getattr(events, "aclose", None) # stopping the reader stops the run
|
|
60
|
+
if close is not None:
|
|
61
|
+
await close()
|
|
@@ -0,0 +1,245 @@
|
|
|
1
|
+
"""The Vercel AI SDK adapter: the UI message stream, for `useChat` and the other clients of the AI SDK.
|
|
2
|
+
|
|
3
|
+
It reads a request into a `ChatInput`, and translates the AG-UI events of a `StreamingRun` into the parts of the UI message
|
|
4
|
+
stream. It is not a server: it gives you the strings, you send them with any web framework.
|
|
5
|
+
|
|
6
|
+
chat_input = parse_request(await request.json())
|
|
7
|
+
run = runner.stream(Support, chat_input)
|
|
8
|
+
return StreamingResponse(encode(run), headers=HEADERS)
|
|
9
|
+
|
|
10
|
+
Written against the protocol as documented at ai-sdk.dev (checked 2026-11-19): see docs/streaming.md.
|
|
11
|
+
"""
|
|
12
|
+
|
|
13
|
+
import json
|
|
14
|
+
import logging
|
|
15
|
+
from collections.abc import AsyncGenerator, Iterable
|
|
16
|
+
from typing import Any
|
|
17
|
+
|
|
18
|
+
from ag_ui.core import (
|
|
19
|
+
AssistantMessage,
|
|
20
|
+
BaseEvent,
|
|
21
|
+
FunctionCall,
|
|
22
|
+
Message,
|
|
23
|
+
ReasoningMessage,
|
|
24
|
+
ToolCall,
|
|
25
|
+
ToolMessage,
|
|
26
|
+
UserMessage,
|
|
27
|
+
)
|
|
28
|
+
from pydantic import ValidationError
|
|
29
|
+
|
|
30
|
+
from featherweight.adapters.errors import BadRequest
|
|
31
|
+
from featherweight.streaming import ChatInput, StreamingRun
|
|
32
|
+
|
|
33
|
+
logger = logging.getLogger(__name__)
|
|
34
|
+
|
|
35
|
+
CONTENT_TYPE = "text/event-stream"
|
|
36
|
+
HEADERS = {
|
|
37
|
+
"Content-Type": CONTENT_TYPE,
|
|
38
|
+
"Cache-Control": "no-cache",
|
|
39
|
+
"Connection": "keep-alive",
|
|
40
|
+
"x-vercel-ai-ui-message-stream": "v1",
|
|
41
|
+
"x-accel-buffering": "no",
|
|
42
|
+
}
|
|
43
|
+
DONE = "data: [DONE]\n\n"
|
|
44
|
+
|
|
45
|
+
|
|
46
|
+
# the request: the messages of the client, as UIMessage, to AG-UI messages
|
|
47
|
+
|
|
48
|
+
|
|
49
|
+
def parse_request(body: dict[str, Any] | str | bytes | list[Any]) -> ChatInput:
|
|
50
|
+
"""The request of `useChat` (`{"id": ..., "messages": [UIMessage, ...]}`, or just the list of messages) as a
|
|
51
|
+
`ChatInput`. `id`, the chat's id, becomes the `thread_id`. Raises `BadRequest` for a body that cannot be read or a
|
|
52
|
+
history that `ChatInput` refuses (a system message, a last message that is not the user's)."""
|
|
53
|
+
if isinstance(body, str | bytes):
|
|
54
|
+
try:
|
|
55
|
+
body = json.loads(body)
|
|
56
|
+
except ValueError as exc:
|
|
57
|
+
raise BadRequest(f"The body is not JSON: {exc}") from exc
|
|
58
|
+
thread_id = None
|
|
59
|
+
if isinstance(body, dict):
|
|
60
|
+
thread_id = body.get("id") if isinstance(body.get("id"), str) else None
|
|
61
|
+
body = body.get("messages") # ty: ignore[invalid-assignment]
|
|
62
|
+
if not isinstance(body, list):
|
|
63
|
+
raise BadRequest("The body needs a list of messages")
|
|
64
|
+
try:
|
|
65
|
+
return ChatInput(messages=to_agui_messages(body), thread_id=thread_id)
|
|
66
|
+
except ValidationError as exc:
|
|
67
|
+
raise BadRequest("; ".join(e["msg"].removeprefix("Value error, ") for e in exc.errors())) from exc
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
def _json(value: Any) -> str:
|
|
71
|
+
return value if isinstance(value, str) else json.dumps(value)
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
def to_agui_messages(ui_messages: list[dict[str, Any]]) -> list[Message]:
|
|
75
|
+
"""UIMessages as AG-UI messages. An assistant UIMessage with tool parts becomes the messages the model saw: an
|
|
76
|
+
assistant message with its tool calls, then the tool results, then the next step's assistant message, and so on."""
|
|
77
|
+
messages: list[Message] = []
|
|
78
|
+
for index, ui in enumerate(ui_messages):
|
|
79
|
+
if not isinstance(ui, dict) or not isinstance(ui.get("parts"), list):
|
|
80
|
+
raise BadRequest(f"messages[{index}] needs a role and a list of parts")
|
|
81
|
+
base = str(ui.get("id") or f"m{index}")
|
|
82
|
+
role = ui.get("role")
|
|
83
|
+
if role == "user":
|
|
84
|
+
text = "".join(p.get("text", "") for p in ui["parts"] if isinstance(p, dict) and p.get("type") == "text")
|
|
85
|
+
messages.append(UserMessage(id=base, content=text))
|
|
86
|
+
elif role == "assistant":
|
|
87
|
+
messages += _assistant(base, ui["parts"])
|
|
88
|
+
elif role == "system":
|
|
89
|
+
raise BadRequest(f"messages[{index}] is a system message: a client cannot send one")
|
|
90
|
+
else:
|
|
91
|
+
raise BadRequest(f"messages[{index}] has the role {role!r}")
|
|
92
|
+
return messages
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def _assistant(base: str, parts: list[dict[str, Any]]) -> list[Message]:
|
|
96
|
+
"""One assistant UIMessage as the messages of its steps."""
|
|
97
|
+
out: list[Message] = []
|
|
98
|
+
step: list[dict[str, Any]] = []
|
|
99
|
+
|
|
100
|
+
def close() -> None:
|
|
101
|
+
if not step:
|
|
102
|
+
return
|
|
103
|
+
text = "".join(p.get("text", "") for p in step if p.get("type") == "text")
|
|
104
|
+
reasoning = "".join(p.get("text", "") for p in step if p.get("type") == "reasoning")
|
|
105
|
+
calls = [p for p in step if str(p.get("type", "")).startswith("tool-") or p.get("type") == "dynamic-tool"]
|
|
106
|
+
message_id = f"{base}-{len(out)}"
|
|
107
|
+
if reasoning:
|
|
108
|
+
out.append(ReasoningMessage(id=f"{message_id}-reasoning", content=reasoning))
|
|
109
|
+
tool_calls = [
|
|
110
|
+
ToolCall(id=c["toolCallId"], function=FunctionCall(name=_tool_name(c), arguments=_json(c.get("input", {}))))
|
|
111
|
+
for c in calls
|
|
112
|
+
if c.get("state") in ("input-available", "output-available", "output-error")
|
|
113
|
+
]
|
|
114
|
+
if text or tool_calls:
|
|
115
|
+
out.append(AssistantMessage(id=message_id, content=text or None, tool_calls=tool_calls or None))
|
|
116
|
+
for c in calls:
|
|
117
|
+
if c.get("state") == "output-available":
|
|
118
|
+
out.append(
|
|
119
|
+
ToolMessage(
|
|
120
|
+
id=f"{c['toolCallId']}-result", tool_call_id=c["toolCallId"], content=_json(c.get("output"))
|
|
121
|
+
)
|
|
122
|
+
)
|
|
123
|
+
elif c.get("state") == "output-error":
|
|
124
|
+
error = str(c.get("errorText", "error"))
|
|
125
|
+
out.append(
|
|
126
|
+
ToolMessage(
|
|
127
|
+
id=f"{c['toolCallId']}-result", tool_call_id=c["toolCallId"], content=error, error=error
|
|
128
|
+
)
|
|
129
|
+
)
|
|
130
|
+
step.clear()
|
|
131
|
+
|
|
132
|
+
for part in parts:
|
|
133
|
+
kind = part.get("type") if isinstance(part, dict) else None
|
|
134
|
+
if kind == "step-start":
|
|
135
|
+
close()
|
|
136
|
+
elif kind in ("text", "reasoning", "dynamic-tool") or str(kind).startswith("tool-"):
|
|
137
|
+
step.append(part)
|
|
138
|
+
# files, sources, data-* and the rest have no counterpart in the model's conversation
|
|
139
|
+
close()
|
|
140
|
+
return out
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
def _tool_name(part: dict[str, Any]) -> str:
|
|
144
|
+
return str(part["toolName"]) if part.get("type") == "dynamic-tool" else str(part["type"]).removeprefix("tool-")
|
|
145
|
+
|
|
146
|
+
|
|
147
|
+
# the response: AG-UI events to the parts of the UI message stream
|
|
148
|
+
|
|
149
|
+
|
|
150
|
+
def _sse(part: dict[str, Any]) -> str:
|
|
151
|
+
return f"data: {json.dumps(part, separators=(',', ':'))}\n\n"
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
class Translator:
|
|
155
|
+
"""Turns the events of one run into the parts of the stream, one event at a time. A part is a dict; `encode` sends them
|
|
156
|
+
as server-sent events. A custom event is a **data part** (`data-<name>`, transient: the client gets it with `onData`, and it is not kept
|
|
157
|
+
in the message); the events that have no part (state, activity, the opaque value of a thought) are dropped."""
|
|
158
|
+
|
|
159
|
+
def __init__(self) -> None:
|
|
160
|
+
self._calls: dict[str, tuple[str, list[str]]] = {} # tool call id -> (name, pieces of its arguments)
|
|
161
|
+
|
|
162
|
+
def feed(self, event: BaseEvent) -> list[dict[str, Any]]:
|
|
163
|
+
kind = event.type.value
|
|
164
|
+
e: Any = event
|
|
165
|
+
if kind == "RUN_STARTED":
|
|
166
|
+
return [{"type": "start", "messageId": e.run_id}]
|
|
167
|
+
if kind == "STEP_STARTED":
|
|
168
|
+
return [{"type": "start-step"}]
|
|
169
|
+
if kind == "STEP_FINISHED":
|
|
170
|
+
return [{"type": "finish-step"}]
|
|
171
|
+
if kind == "TEXT_MESSAGE_START":
|
|
172
|
+
return [{"type": "text-start", "id": e.message_id}]
|
|
173
|
+
if kind == "TEXT_MESSAGE_CONTENT":
|
|
174
|
+
return [{"type": "text-delta", "id": e.message_id, "delta": e.delta}]
|
|
175
|
+
if kind == "TEXT_MESSAGE_END":
|
|
176
|
+
return [{"type": "text-end", "id": e.message_id}]
|
|
177
|
+
if kind == "REASONING_START":
|
|
178
|
+
return [{"type": "reasoning-start", "id": e.message_id}]
|
|
179
|
+
if kind == "REASONING_MESSAGE_CONTENT":
|
|
180
|
+
return [{"type": "reasoning-delta", "id": e.message_id, "delta": e.delta}]
|
|
181
|
+
if kind == "REASONING_END":
|
|
182
|
+
return [{"type": "reasoning-end", "id": e.message_id}]
|
|
183
|
+
if kind == "TOOL_CALL_START":
|
|
184
|
+
self._calls[e.tool_call_id] = (e.tool_call_name, [])
|
|
185
|
+
return [{"type": "tool-input-start", "toolCallId": e.tool_call_id, "toolName": e.tool_call_name}]
|
|
186
|
+
if kind == "TOOL_CALL_ARGS":
|
|
187
|
+
if e.tool_call_id in self._calls:
|
|
188
|
+
self._calls[e.tool_call_id][1].append(e.delta)
|
|
189
|
+
return [{"type": "tool-input-delta", "toolCallId": e.tool_call_id, "inputTextDelta": e.delta}]
|
|
190
|
+
if kind == "TOOL_CALL_END":
|
|
191
|
+
name, pieces = self._calls.pop(e.tool_call_id, ("", []))
|
|
192
|
+
return [
|
|
193
|
+
{
|
|
194
|
+
"type": "tool-input-available",
|
|
195
|
+
"toolCallId": e.tool_call_id,
|
|
196
|
+
"toolName": name,
|
|
197
|
+
"input": _parse("".join(pieces)),
|
|
198
|
+
}
|
|
199
|
+
]
|
|
200
|
+
if kind == "TOOL_CALL_RESULT":
|
|
201
|
+
return [{"type": "tool-output-available", "toolCallId": e.tool_call_id, "output": _parse(e.content)}]
|
|
202
|
+
if kind == "RUN_FINISHED":
|
|
203
|
+
if getattr(e.outcome, "type", "success") == "cancelled":
|
|
204
|
+
return [{"type": "abort", "reason": "stopped by the user"}]
|
|
205
|
+
return [{"type": "finish"}]
|
|
206
|
+
if kind == "RUN_ERROR":
|
|
207
|
+
return [{"type": "error", "errorText": e.message}]
|
|
208
|
+
if kind == "CUSTOM": # `background_started` and `background_finished`: a data part, not kept in the messages
|
|
209
|
+
return [{"type": f"data-{e.name}", "data": e.value, "transient": True}]
|
|
210
|
+
return []
|
|
211
|
+
|
|
212
|
+
|
|
213
|
+
def _parse(text: Any) -> Any:
|
|
214
|
+
"""The JSON a tool's arguments or result holds, or the text itself when it is not JSON."""
|
|
215
|
+
if not isinstance(text, str):
|
|
216
|
+
return text
|
|
217
|
+
if not text.strip():
|
|
218
|
+
return {}
|
|
219
|
+
try:
|
|
220
|
+
return json.loads(text)
|
|
221
|
+
except ValueError:
|
|
222
|
+
return text
|
|
223
|
+
|
|
224
|
+
|
|
225
|
+
def translate(events: Iterable[BaseEvent]) -> list[str]:
|
|
226
|
+
"""The events of a whole run as server-sent events, ending with `[DONE]`. For tests and replays; use `encode` to stream."""
|
|
227
|
+
translator = Translator()
|
|
228
|
+
out = [_sse(part) for event in events for part in translator.feed(event)]
|
|
229
|
+
return [*out, DONE]
|
|
230
|
+
|
|
231
|
+
|
|
232
|
+
async def encode(run: StreamingRun) -> AsyncGenerator[str, None]:
|
|
233
|
+
"""The server-sent events of a run, as it streams, ending with `[DONE]`. Send them with the headers in `HEADERS`.
|
|
234
|
+
Stopping the iteration (a client that went away) stops the run."""
|
|
235
|
+
translator = Translator()
|
|
236
|
+
events = aiter(run)
|
|
237
|
+
try:
|
|
238
|
+
async for event in events:
|
|
239
|
+
for part in translator.feed(event):
|
|
240
|
+
yield _sse(part)
|
|
241
|
+
yield DONE
|
|
242
|
+
finally:
|
|
243
|
+
close = getattr(events, "aclose", None) # an early stop closes the run
|
|
244
|
+
if close is not None:
|
|
245
|
+
await close()
|