levier-runtime 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.
- levier_runtime/__init__.py +57 -0
- levier_runtime/channel/__init__.py +5 -0
- levier_runtime/channel/client.py +317 -0
- levier_runtime/channel/envelope.py +57 -0
- levier_runtime/cli.py +116 -0
- levier_runtime/config.py +289 -0
- levier_runtime/context.py +409 -0
- levier_runtime/events.py +100 -0
- levier_runtime/ids.py +36 -0
- levier_runtime/llm/__init__.py +44 -0
- levier_runtime/llm/anthropic.py +410 -0
- levier_runtime/llm/base.py +134 -0
- levier_runtime/llm/http.py +133 -0
- levier_runtime/llm/openai.py +379 -0
- levier_runtime/llm/router.py +56 -0
- levier_runtime/manager.py +272 -0
- levier_runtime/mcp/__init__.py +8 -0
- levier_runtime/mcp/client.py +289 -0
- levier_runtime/profile.py +91 -0
- levier_runtime/react/__init__.py +11 -0
- levier_runtime/react/agent.py +527 -0
- levier_runtime/react/checkpoint.py +193 -0
- levier_runtime/runtime.py +139 -0
- levier_runtime/toolbox.py +261 -0
- levier_runtime/tools/__init__.py +23 -0
- levier_runtime/tools/base.py +131 -0
- levier_runtime/types.py +143 -0
- levier_runtime-0.1.0.dist-info/METADATA +101 -0
- levier_runtime-0.1.0.dist-info/RECORD +37 -0
- levier_runtime-0.1.0.dist-info/WHEEL +5 -0
- levier_runtime-0.1.0.dist-info/top_level.txt +2 -0
- middleware/__init__.py +1 -0
- middleware/runtime/__init__.py +1 -0
- middleware/runtime/v1/__init__.py +1 -0
- middleware/runtime/v1/runtime_pb2.py +98 -0
- middleware/runtime/v1/runtime_pb2.pyi +332 -0
- middleware/runtime/v1/runtime_pb2_grpc.py +84 -0
levier_runtime/events.py
ADDED
|
@@ -0,0 +1,100 @@
|
|
|
1
|
+
"""Per-run event sequencing for the Runtime SDK.
|
|
2
|
+
|
|
3
|
+
The SDK owns sequence numbers. A runtime only emits event names and data.
|
|
4
|
+
|
|
5
|
+
Copyright 2026 The Levier Authors.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from __future__ import annotations
|
|
9
|
+
|
|
10
|
+
from typing import Any, Protocol
|
|
11
|
+
|
|
12
|
+
from google.protobuf import struct_pb2
|
|
13
|
+
from middleware.runtime.v1 import runtime_pb2
|
|
14
|
+
|
|
15
|
+
from .channel.envelope import new_envelope
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
class EventSender(Protocol):
|
|
19
|
+
"""Minimal sender interface used by EventWriter."""
|
|
20
|
+
|
|
21
|
+
async def send(self, envelope: runtime_pb2.Envelope) -> None:
|
|
22
|
+
"""Send one envelope."""
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
class EventWriter:
|
|
26
|
+
"""Write persistent and ephemeral events for one run attempt."""
|
|
27
|
+
|
|
28
|
+
def __init__(
|
|
29
|
+
self,
|
|
30
|
+
sender: EventSender,
|
|
31
|
+
run_id: str,
|
|
32
|
+
attempt: int,
|
|
33
|
+
lease_epoch: int,
|
|
34
|
+
) -> None:
|
|
35
|
+
self.sender = sender
|
|
36
|
+
self.run_id = run_id
|
|
37
|
+
self.attempt = attempt
|
|
38
|
+
self.lease_epoch = lease_epoch
|
|
39
|
+
self.seq = 0
|
|
40
|
+
|
|
41
|
+
async def emit(
|
|
42
|
+
self,
|
|
43
|
+
event_type: str | int,
|
|
44
|
+
data: dict[str, Any],
|
|
45
|
+
*,
|
|
46
|
+
ephemeral: bool = False,
|
|
47
|
+
) -> None:
|
|
48
|
+
"""Emit one event; only persistent events consume a sequence number."""
|
|
49
|
+
if isinstance(event_type, str):
|
|
50
|
+
try:
|
|
51
|
+
wire_type = runtime_pb2.EventType.Value(event_type)
|
|
52
|
+
except ValueError as exc:
|
|
53
|
+
raise ValueError(f"unknown runtime event type {event_type!r}") from exc
|
|
54
|
+
else:
|
|
55
|
+
wire_type = event_type
|
|
56
|
+
if ephemeral:
|
|
57
|
+
seq = 0
|
|
58
|
+
else:
|
|
59
|
+
self.seq += 1
|
|
60
|
+
seq = self.seq
|
|
61
|
+
|
|
62
|
+
payload = struct_pb2.Struct()
|
|
63
|
+
payload.update(data or {})
|
|
64
|
+
event = runtime_pb2.Event(
|
|
65
|
+
seq=seq,
|
|
66
|
+
type=wire_type,
|
|
67
|
+
ephemeral=ephemeral,
|
|
68
|
+
source="daemon",
|
|
69
|
+
data=payload,
|
|
70
|
+
)
|
|
71
|
+
await self.sender.send(new_envelope(
|
|
72
|
+
event,
|
|
73
|
+
"event",
|
|
74
|
+
run_id=self.run_id,
|
|
75
|
+
attempt=self.attempt,
|
|
76
|
+
lease_epoch=self.lease_epoch,
|
|
77
|
+
))
|
|
78
|
+
|
|
79
|
+
async def emit_checkpoint(
|
|
80
|
+
self,
|
|
81
|
+
session_id: str,
|
|
82
|
+
state: bytes,
|
|
83
|
+
*,
|
|
84
|
+
watermark: int | None = None,
|
|
85
|
+
) -> int:
|
|
86
|
+
"""Send one checkpoint covering the current persistent event sequence."""
|
|
87
|
+
covered = self.seq if watermark is None else watermark
|
|
88
|
+
checkpoint = runtime_pb2.Checkpoint(
|
|
89
|
+
session_id=session_id,
|
|
90
|
+
event_seq_watermark=covered,
|
|
91
|
+
state=state,
|
|
92
|
+
)
|
|
93
|
+
await self.sender.send(new_envelope(
|
|
94
|
+
checkpoint,
|
|
95
|
+
"checkpoint",
|
|
96
|
+
run_id=self.run_id,
|
|
97
|
+
attempt=self.attempt,
|
|
98
|
+
lease_epoch=self.lease_epoch,
|
|
99
|
+
))
|
|
100
|
+
return covered
|
levier_runtime/ids.py
ADDED
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
"""Levier ? Runtime SDK identifier helpers.
|
|
2
|
+
|
|
3
|
+
Generates ULIDs locally so the runtime can create valid message IDs
|
|
4
|
+
without an extra dependency.
|
|
5
|
+
|
|
6
|
+
Copyright 2026 The Levier Authors.
|
|
7
|
+
"""
|
|
8
|
+
|
|
9
|
+
from __future__ import annotations
|
|
10
|
+
|
|
11
|
+
import os
|
|
12
|
+
import time
|
|
13
|
+
|
|
14
|
+
_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
def new_ulid(timestamp_ms: int | None = None) -> str:
|
|
18
|
+
"""Return a 26-character Crockford Base32 ULID."""
|
|
19
|
+
timestamp = int(time.time() * 1000) if timestamp_ms is None else timestamp_ms
|
|
20
|
+
timestamp &= (1 << 48) - 1
|
|
21
|
+
randomness = int.from_bytes(os.urandom(10), "big")
|
|
22
|
+
value = (timestamp << 80) | randomness
|
|
23
|
+
return "".join(
|
|
24
|
+
_ALPHABET[(value >> (5 * (25 - index))) & 0x1F]
|
|
25
|
+
for index in range(26)
|
|
26
|
+
)
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
def ulid_timestamp_ms(value: str) -> int:
|
|
30
|
+
"""Extract the millisecond timestamp from a 26-character ULID."""
|
|
31
|
+
if len(value) != 26:
|
|
32
|
+
raise ValueError("ULID must be 26 characters")
|
|
33
|
+
number = 0
|
|
34
|
+
for char in value.upper():
|
|
35
|
+
number = (number << 5) | _ALPHABET.index(char)
|
|
36
|
+
return (number >> 80) & ((1 << 48) - 1)
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
"""Levier - optional LLM providers.
|
|
2
|
+
|
|
3
|
+
Copyright 2026 The Levier Authors.
|
|
4
|
+
"""
|
|
5
|
+
|
|
6
|
+
from levier_runtime.llm.anthropic import AnthropicProvider
|
|
7
|
+
from levier_runtime.llm.base import (
|
|
8
|
+
DeltaCallback,
|
|
9
|
+
LLMError,
|
|
10
|
+
LLMProvider,
|
|
11
|
+
LLMResponse,
|
|
12
|
+
Message,
|
|
13
|
+
ModelConfig,
|
|
14
|
+
ToolCall,
|
|
15
|
+
ToolSpec,
|
|
16
|
+
)
|
|
17
|
+
from levier_runtime.llm.openai import OpenAICompatibleProvider
|
|
18
|
+
from levier_runtime.llm.router import ProviderRouter
|
|
19
|
+
from levier_runtime.llm.http import (
|
|
20
|
+
HTTPRequest,
|
|
21
|
+
HTTPResponse,
|
|
22
|
+
HTTPTransport,
|
|
23
|
+
HTTPTransportError,
|
|
24
|
+
UrllibTransport,
|
|
25
|
+
)
|
|
26
|
+
|
|
27
|
+
__all__ = [
|
|
28
|
+
"AnthropicProvider",
|
|
29
|
+
"DeltaCallback",
|
|
30
|
+
"HTTPRequest",
|
|
31
|
+
"HTTPResponse",
|
|
32
|
+
"HTTPTransport",
|
|
33
|
+
"HTTPTransportError",
|
|
34
|
+
"LLMError",
|
|
35
|
+
"LLMProvider",
|
|
36
|
+
"LLMResponse",
|
|
37
|
+
"Message",
|
|
38
|
+
"OpenAICompatibleProvider",
|
|
39
|
+
"ProviderRouter",
|
|
40
|
+
"ModelConfig",
|
|
41
|
+
"ToolCall",
|
|
42
|
+
"ToolSpec",
|
|
43
|
+
"UrllibTransport",
|
|
44
|
+
]
|
|
@@ -0,0 +1,410 @@
|
|
|
1
|
+
"""Levier — Anthropic Messages API provider.
|
|
2
|
+
|
|
3
|
+
Builds Anthropic requests from the provider-neutral message model, parses
|
|
4
|
+
server-sent events, streams text deltas, and normalizes errors.
|
|
5
|
+
|
|
6
|
+
Copyright 2026 The Levier Authors.
|
|
7
|
+
"""
|
|
8
|
+
|
|
9
|
+
from __future__ import annotations
|
|
10
|
+
|
|
11
|
+
import json
|
|
12
|
+
import os
|
|
13
|
+
from typing import AsyncIterator, Sequence
|
|
14
|
+
|
|
15
|
+
from levier_runtime.llm.base import (
|
|
16
|
+
DeltaCallback,
|
|
17
|
+
LLMError,
|
|
18
|
+
LLMResponse,
|
|
19
|
+
Message,
|
|
20
|
+
ModelConfig,
|
|
21
|
+
ToolCall,
|
|
22
|
+
ToolSpec,
|
|
23
|
+
)
|
|
24
|
+
from levier_runtime.llm.http import (
|
|
25
|
+
HTTPRequest,
|
|
26
|
+
HTTPResponse,
|
|
27
|
+
HTTPTransport,
|
|
28
|
+
HTTPTransportError,
|
|
29
|
+
UrllibTransport,
|
|
30
|
+
)
|
|
31
|
+
|
|
32
|
+
_DEFAULT_BASE_URL = "https://api.anthropic.com/v1/messages"
|
|
33
|
+
_DEFAULT_MAX_TOKENS = 4096
|
|
34
|
+
_DEFAULT_ANTHROPIC_VERSION = "2023-06-01"
|
|
35
|
+
|
|
36
|
+
_RETRYABLE_STATUS = {408, 409, 429, 500, 502, 503, 504, 529}
|
|
37
|
+
_RETRYABLE_ERROR_TYPES = {
|
|
38
|
+
"api_error",
|
|
39
|
+
"overloaded_error",
|
|
40
|
+
"rate_limit_error",
|
|
41
|
+
"timeout_error",
|
|
42
|
+
}
|
|
43
|
+
_ERROR_CODE_BY_TYPE = {
|
|
44
|
+
"api_error": "PROVIDER_ERROR",
|
|
45
|
+
"authentication_error": "AUTH_FAILED",
|
|
46
|
+
"invalid_request_error": "BAD_REQUEST",
|
|
47
|
+
"not_found_error": "BAD_REQUEST",
|
|
48
|
+
"overloaded_error": "PROVIDER_UNAVAILABLE",
|
|
49
|
+
"permission_error": "AUTH_FAILED",
|
|
50
|
+
"rate_limit_error": "RATE_LIMITED",
|
|
51
|
+
"timeout_error": "TIMEOUT",
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
class AnthropicProvider:
|
|
56
|
+
"""Anthropic Messages API provider."""
|
|
57
|
+
|
|
58
|
+
def __init__(
|
|
59
|
+
self,
|
|
60
|
+
transport: HTTPTransport | None = None,
|
|
61
|
+
*,
|
|
62
|
+
api_version: str = _DEFAULT_ANTHROPIC_VERSION,
|
|
63
|
+
default_max_tokens: int = _DEFAULT_MAX_TOKENS,
|
|
64
|
+
) -> None:
|
|
65
|
+
self.transport = transport or UrllibTransport()
|
|
66
|
+
self.api_version = api_version
|
|
67
|
+
self.default_max_tokens = default_max_tokens
|
|
68
|
+
|
|
69
|
+
async def complete(
|
|
70
|
+
self,
|
|
71
|
+
messages: Sequence[Message],
|
|
72
|
+
tools: Sequence[ToolSpec],
|
|
73
|
+
model: ModelConfig,
|
|
74
|
+
*,
|
|
75
|
+
on_delta: DeltaCallback | None = None,
|
|
76
|
+
) -> LLMResponse:
|
|
77
|
+
"""Call the Messages API and parse either SSE or JSON responses."""
|
|
78
|
+
request = self.build_request(messages, tools, model)
|
|
79
|
+
try:
|
|
80
|
+
response = await self.transport.open(request)
|
|
81
|
+
except HTTPTransportError as exc:
|
|
82
|
+
raise LLMError(
|
|
83
|
+
"PROVIDER_UNAVAILABLE",
|
|
84
|
+
str(exc),
|
|
85
|
+
retryable=True,
|
|
86
|
+
) from exc
|
|
87
|
+
|
|
88
|
+
if response.status != 200:
|
|
89
|
+
body = await _read_body(response.body)
|
|
90
|
+
raise _http_error(response.status, body)
|
|
91
|
+
|
|
92
|
+
if "application/json" in response.headers.get("content-type", ""):
|
|
93
|
+
body = await _read_body(response.body)
|
|
94
|
+
return _parse_json_response(body, model)
|
|
95
|
+
|
|
96
|
+
return await _parse_stream(response.body, model, on_delta)
|
|
97
|
+
|
|
98
|
+
def build_request(
|
|
99
|
+
self,
|
|
100
|
+
messages: Sequence[Message],
|
|
101
|
+
tools: Sequence[ToolSpec],
|
|
102
|
+
model: ModelConfig,
|
|
103
|
+
) -> HTTPRequest:
|
|
104
|
+
"""Build one streaming Messages API request."""
|
|
105
|
+
if not model.model:
|
|
106
|
+
raise LLMError("BAD_REQUEST", "model is required", retryable=False)
|
|
107
|
+
|
|
108
|
+
system, payload_messages = _convert_messages(messages)
|
|
109
|
+
body: dict[str, object] = {
|
|
110
|
+
"model": model.model,
|
|
111
|
+
"max_tokens": _int_param(model.params, "max_tokens", self.default_max_tokens),
|
|
112
|
+
"stream": True,
|
|
113
|
+
"messages": payload_messages,
|
|
114
|
+
}
|
|
115
|
+
if system:
|
|
116
|
+
body["system"] = system
|
|
117
|
+
if tools:
|
|
118
|
+
body["tools"] = [_tool_schema(tool) for tool in tools]
|
|
119
|
+
for key in ("temperature", "top_p", "top_k"):
|
|
120
|
+
if key in model.params:
|
|
121
|
+
try:
|
|
122
|
+
body[key] = float(model.params[key])
|
|
123
|
+
except ValueError as exc:
|
|
124
|
+
raise LLMError(
|
|
125
|
+
"BAD_REQUEST",
|
|
126
|
+
f"model parameter {key} must be numeric",
|
|
127
|
+
retryable=False,
|
|
128
|
+
) from exc
|
|
129
|
+
|
|
130
|
+
headers = {
|
|
131
|
+
"accept": "text/event-stream",
|
|
132
|
+
"anthropic-version": self.api_version,
|
|
133
|
+
"content-type": "application/json",
|
|
134
|
+
}
|
|
135
|
+
api_key = model.api_key or os.environ.get("ANTHROPIC_API_KEY", "").strip()
|
|
136
|
+
if api_key:
|
|
137
|
+
headers["x-api-key"] = api_key
|
|
138
|
+
return HTTPRequest(
|
|
139
|
+
url=model.base_url or _DEFAULT_BASE_URL,
|
|
140
|
+
headers=headers,
|
|
141
|
+
body=json.dumps(body, ensure_ascii=False).encode("utf-8"),
|
|
142
|
+
)
|
|
143
|
+
|
|
144
|
+
|
|
145
|
+
async def _parse_stream(
|
|
146
|
+
chunks: AsyncIterator[bytes],
|
|
147
|
+
model: ModelConfig,
|
|
148
|
+
on_delta: DeltaCallback | None,
|
|
149
|
+
) -> LLMResponse:
|
|
150
|
+
text_parts: list[str] = []
|
|
151
|
+
tool_calls: dict[int, dict[str, str]] = {}
|
|
152
|
+
usage: dict[str, int] = {}
|
|
153
|
+
response_model = model.model
|
|
154
|
+
|
|
155
|
+
try:
|
|
156
|
+
async for event in _iter_sse(chunks):
|
|
157
|
+
kind = event.get("type")
|
|
158
|
+
if kind == "message_start":
|
|
159
|
+
message = event.get("message") or {}
|
|
160
|
+
response_model = message.get("model") or response_model
|
|
161
|
+
_merge_usage(usage, message.get("usage"))
|
|
162
|
+
elif kind == "content_block_start":
|
|
163
|
+
block = event.get("content_block") or {}
|
|
164
|
+
index = int(event.get("index", 0))
|
|
165
|
+
if block.get("type") == "tool_use":
|
|
166
|
+
tool_calls[index] = {
|
|
167
|
+
"call_id": str(block.get("id", "")),
|
|
168
|
+
"name": str(block.get("name", "")),
|
|
169
|
+
"arguments_json": "",
|
|
170
|
+
}
|
|
171
|
+
elif block.get("text"):
|
|
172
|
+
text = str(block["text"])
|
|
173
|
+
text_parts.append(text)
|
|
174
|
+
if on_delta is not None:
|
|
175
|
+
await on_delta(text)
|
|
176
|
+
elif kind == "content_block_delta":
|
|
177
|
+
index = int(event.get("index", 0))
|
|
178
|
+
delta = event.get("delta") or {}
|
|
179
|
+
if delta.get("type") == "text_delta":
|
|
180
|
+
text = str(delta.get("text", ""))
|
|
181
|
+
if text:
|
|
182
|
+
text_parts.append(text)
|
|
183
|
+
if on_delta is not None:
|
|
184
|
+
await on_delta(text)
|
|
185
|
+
elif delta.get("type") == "input_json_delta":
|
|
186
|
+
call = tool_calls.setdefault(
|
|
187
|
+
index,
|
|
188
|
+
{"call_id": "", "name": "", "arguments_json": ""},
|
|
189
|
+
)
|
|
190
|
+
call["arguments_json"] += str(delta.get("partial_json", ""))
|
|
191
|
+
elif kind == "message_delta":
|
|
192
|
+
_merge_usage(usage, event.get("usage"))
|
|
193
|
+
elif kind == "error":
|
|
194
|
+
raise _stream_error(event)
|
|
195
|
+
elif kind == "message_stop":
|
|
196
|
+
break
|
|
197
|
+
finally:
|
|
198
|
+
aclose = getattr(chunks, "aclose", None)
|
|
199
|
+
if aclose is not None:
|
|
200
|
+
await aclose()
|
|
201
|
+
|
|
202
|
+
calls = [
|
|
203
|
+
ToolCall(
|
|
204
|
+
call_id=call["call_id"],
|
|
205
|
+
name=call["name"],
|
|
206
|
+
arguments_json=call["arguments_json"] or "{}",
|
|
207
|
+
)
|
|
208
|
+
for _, call in sorted(tool_calls.items())
|
|
209
|
+
]
|
|
210
|
+
return LLMResponse(
|
|
211
|
+
content="".join(text_parts),
|
|
212
|
+
tool_calls=calls,
|
|
213
|
+
usage=usage,
|
|
214
|
+
model=response_model,
|
|
215
|
+
)
|
|
216
|
+
|
|
217
|
+
|
|
218
|
+
async def _iter_sse(chunks: AsyncIterator[bytes]) -> AsyncIterator[dict[str, object]]:
|
|
219
|
+
buffer = ""
|
|
220
|
+
async for chunk in chunks:
|
|
221
|
+
buffer += chunk.decode("utf-8", errors="replace").replace("\r\n", "\n")
|
|
222
|
+
while "\n\n" in buffer:
|
|
223
|
+
block, buffer = buffer.split("\n\n", 1)
|
|
224
|
+
data_lines = [
|
|
225
|
+
line[5:].strip()
|
|
226
|
+
for line in block.splitlines()
|
|
227
|
+
if line.startswith("data:")
|
|
228
|
+
]
|
|
229
|
+
if not data_lines:
|
|
230
|
+
continue
|
|
231
|
+
data = "\n".join(data_lines)
|
|
232
|
+
if data == "[DONE]":
|
|
233
|
+
return
|
|
234
|
+
try:
|
|
235
|
+
parsed = json.loads(data)
|
|
236
|
+
except json.JSONDecodeError:
|
|
237
|
+
continue
|
|
238
|
+
if isinstance(parsed, dict):
|
|
239
|
+
yield parsed
|
|
240
|
+
|
|
241
|
+
|
|
242
|
+
def _parse_json_response(body: bytes, model: ModelConfig) -> LLMResponse:
|
|
243
|
+
try:
|
|
244
|
+
payload = json.loads(body.decode("utf-8"))
|
|
245
|
+
except (UnicodeDecodeError, json.JSONDecodeError) as exc:
|
|
246
|
+
raise LLMError("BAD_RESPONSE", "provider returned invalid JSON", retryable=False) from exc
|
|
247
|
+
|
|
248
|
+
text_parts: list[str] = []
|
|
249
|
+
tool_calls: list[ToolCall] = []
|
|
250
|
+
for block in payload.get("content") or []:
|
|
251
|
+
if block.get("type") == "text":
|
|
252
|
+
text_parts.append(str(block.get("text", "")))
|
|
253
|
+
elif block.get("type") == "tool_use":
|
|
254
|
+
tool_calls.append(
|
|
255
|
+
ToolCall(
|
|
256
|
+
call_id=str(block.get("id", "")),
|
|
257
|
+
name=str(block.get("name", "")),
|
|
258
|
+
arguments_json=json.dumps(
|
|
259
|
+
block.get("input") or {},
|
|
260
|
+
ensure_ascii=False,
|
|
261
|
+
separators=(",", ":"),
|
|
262
|
+
),
|
|
263
|
+
)
|
|
264
|
+
)
|
|
265
|
+
usage: dict[str, int] = {}
|
|
266
|
+
_merge_usage(usage, payload.get("usage"))
|
|
267
|
+
return LLMResponse(
|
|
268
|
+
content="".join(text_parts),
|
|
269
|
+
tool_calls=tool_calls,
|
|
270
|
+
usage=usage,
|
|
271
|
+
model=str(payload.get("model") or model.model),
|
|
272
|
+
)
|
|
273
|
+
|
|
274
|
+
|
|
275
|
+
def _convert_messages(messages: Sequence[Message]) -> tuple[str, list[dict[str, object]]]:
|
|
276
|
+
system_parts: list[str] = []
|
|
277
|
+
converted: list[dict[str, object]] = []
|
|
278
|
+
pending_tool_results: list[dict[str, object]] = []
|
|
279
|
+
|
|
280
|
+
def flush_tool_results() -> None:
|
|
281
|
+
if pending_tool_results:
|
|
282
|
+
converted.append({"role": "user", "content": list(pending_tool_results)})
|
|
283
|
+
pending_tool_results.clear()
|
|
284
|
+
|
|
285
|
+
for message in messages:
|
|
286
|
+
if message.role == "system":
|
|
287
|
+
if message.content:
|
|
288
|
+
system_parts.append(message.content)
|
|
289
|
+
continue
|
|
290
|
+
if message.role == "tool":
|
|
291
|
+
pending_tool_results.append(
|
|
292
|
+
{
|
|
293
|
+
"type": "tool_result",
|
|
294
|
+
"tool_use_id": message.tool_call_id,
|
|
295
|
+
"content": message.content,
|
|
296
|
+
}
|
|
297
|
+
)
|
|
298
|
+
continue
|
|
299
|
+
|
|
300
|
+
flush_tool_results()
|
|
301
|
+
if message.role == "assistant" and message.tool_calls:
|
|
302
|
+
blocks: list[dict[str, object]] = []
|
|
303
|
+
if message.content:
|
|
304
|
+
blocks.append({"type": "text", "text": message.content})
|
|
305
|
+
for call in message.tool_calls:
|
|
306
|
+
blocks.append(
|
|
307
|
+
{
|
|
308
|
+
"type": "tool_use",
|
|
309
|
+
"id": call.call_id,
|
|
310
|
+
"name": call.name,
|
|
311
|
+
"input": _parse_arguments(call.arguments_json),
|
|
312
|
+
}
|
|
313
|
+
)
|
|
314
|
+
converted.append({"role": "assistant", "content": blocks})
|
|
315
|
+
elif message.content:
|
|
316
|
+
converted.append({"role": message.role, "content": message.content})
|
|
317
|
+
|
|
318
|
+
flush_tool_results()
|
|
319
|
+
return "\n\n".join(system_parts), converted
|
|
320
|
+
|
|
321
|
+
|
|
322
|
+
def _tool_schema(tool: ToolSpec) -> dict[str, object]:
|
|
323
|
+
try:
|
|
324
|
+
schema = json.loads(tool.input_schema_json or "{}")
|
|
325
|
+
except json.JSONDecodeError as exc:
|
|
326
|
+
raise LLMError(
|
|
327
|
+
"BAD_REQUEST",
|
|
328
|
+
f"tool {tool.name!r} has an invalid input schema",
|
|
329
|
+
retryable=False,
|
|
330
|
+
) from exc
|
|
331
|
+
return {
|
|
332
|
+
"name": tool.name,
|
|
333
|
+
"description": tool.description,
|
|
334
|
+
"input_schema": schema or {"type": "object"},
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
|
|
338
|
+
def _parse_arguments(arguments_json: str) -> dict[str, object]:
|
|
339
|
+
if not arguments_json:
|
|
340
|
+
return {}
|
|
341
|
+
try:
|
|
342
|
+
parsed = json.loads(arguments_json)
|
|
343
|
+
except json.JSONDecodeError as exc:
|
|
344
|
+
raise LLMError(
|
|
345
|
+
"BAD_REQUEST",
|
|
346
|
+
"model returned invalid tool arguments",
|
|
347
|
+
retryable=False,
|
|
348
|
+
) from exc
|
|
349
|
+
return parsed if isinstance(parsed, dict) else {"value": parsed}
|
|
350
|
+
|
|
351
|
+
|
|
352
|
+
def _merge_usage(target: dict[str, int], usage: object) -> None:
|
|
353
|
+
if not isinstance(usage, dict):
|
|
354
|
+
return
|
|
355
|
+
for key, value in usage.items():
|
|
356
|
+
if isinstance(value, bool):
|
|
357
|
+
continue
|
|
358
|
+
if isinstance(value, int):
|
|
359
|
+
target[key] = value
|
|
360
|
+
|
|
361
|
+
|
|
362
|
+
def _http_error(status: int, body: bytes) -> LLMError:
|
|
363
|
+
code = "PROVIDER_UNAVAILABLE" if status in _RETRYABLE_STATUS else "PROVIDER_ERROR"
|
|
364
|
+
message = f"provider returned HTTP {status}"
|
|
365
|
+
try:
|
|
366
|
+
payload = json.loads(body.decode("utf-8"))
|
|
367
|
+
error = payload.get("error") or {}
|
|
368
|
+
if error.get("message"):
|
|
369
|
+
message = str(error["message"])
|
|
370
|
+
mapped = _ERROR_CODE_BY_TYPE.get(str(error.get("type", "")))
|
|
371
|
+
if mapped:
|
|
372
|
+
code = mapped
|
|
373
|
+
except (UnicodeDecodeError, json.JSONDecodeError):
|
|
374
|
+
pass
|
|
375
|
+
return LLMError(code, message, retryable=status in _RETRYABLE_STATUS, status=status)
|
|
376
|
+
|
|
377
|
+
|
|
378
|
+
def _stream_error(event: dict[str, object]) -> LLMError:
|
|
379
|
+
error = event.get("error") or {}
|
|
380
|
+
if not isinstance(error, dict):
|
|
381
|
+
error = {}
|
|
382
|
+
error_type = str(error.get("type", ""))
|
|
383
|
+
code = _ERROR_CODE_BY_TYPE.get(error_type, "PROVIDER_ERROR")
|
|
384
|
+
return LLMError(
|
|
385
|
+
code,
|
|
386
|
+
str(error.get("message") or "provider stream error"),
|
|
387
|
+
retryable=error_type in _RETRYABLE_ERROR_TYPES,
|
|
388
|
+
)
|
|
389
|
+
|
|
390
|
+
|
|
391
|
+
async def _read_body(chunks: AsyncIterator[bytes]) -> bytes:
|
|
392
|
+
parts: list[bytes] = []
|
|
393
|
+
try:
|
|
394
|
+
async for chunk in chunks:
|
|
395
|
+
parts.append(chunk)
|
|
396
|
+
finally:
|
|
397
|
+
aclose = getattr(chunks, "aclose", None)
|
|
398
|
+
if aclose is not None:
|
|
399
|
+
await aclose()
|
|
400
|
+
return b"".join(parts)
|
|
401
|
+
|
|
402
|
+
|
|
403
|
+
def _int_param(params: dict[str, str], name: str, default: int) -> int:
|
|
404
|
+
value = params.get(name)
|
|
405
|
+
if value is None:
|
|
406
|
+
return default
|
|
407
|
+
try:
|
|
408
|
+
return int(value)
|
|
409
|
+
except ValueError:
|
|
410
|
+
return default
|