caveman-middleware 0.1.0a1__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.
- caveman_middleware/__init__.py +2 -0
- caveman_middleware/_google_wire.py +84 -0
- caveman_middleware/_httpx2.py +190 -0
- caveman_middleware/_native.py +292 -0
- caveman_middleware/_streams.py +60 -0
- caveman_middleware/_usage.py +91 -0
- caveman_middleware/_versions.py +63 -0
- caveman_middleware/agno.py +557 -0
- caveman_middleware/anthropic.py +158 -0
- caveman_middleware/asgi.py +210 -0
- caveman_middleware/autogen.py +507 -0
- caveman_middleware/crewai.py +338 -0
- caveman_middleware/google.py +493 -0
- caveman_middleware/langchain.py +398 -0
- caveman_middleware/litellm.py +375 -0
- caveman_middleware/llama_index.py +807 -0
- caveman_middleware/mcp.py +126 -0
- caveman_middleware/openai.py +215 -0
- caveman_middleware/py.typed +0 -0
- caveman_middleware/pydantic_ai.py +310 -0
- caveman_middleware/strands.py +210 -0
- caveman_middleware-0.1.0a1.dist-info/METADATA +143 -0
- caveman_middleware-0.1.0a1.dist-info/RECORD +26 -0
- caveman_middleware-0.1.0a1.dist-info/WHEEL +5 -0
- caveman_middleware-0.1.0a1.dist-info/licenses/LICENSE +21 -0
- caveman_middleware-0.1.0a1.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
"""Bounded Google JSON string offsets; untouched serialized text stays exact."""
|
|
2
|
+
import json
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
def parse(text):
|
|
6
|
+
if len(text) > 2 << 20:
|
|
7
|
+
return None
|
|
8
|
+
decoder, strings, index, nodes = json.JSONDecoder(), {}, 0, 0
|
|
9
|
+
|
|
10
|
+
def white():
|
|
11
|
+
nonlocal index
|
|
12
|
+
while index < len(text) and text[index] in " \t\r\n":
|
|
13
|
+
index += 1
|
|
14
|
+
|
|
15
|
+
def walk(path, depth=0):
|
|
16
|
+
nonlocal index, nodes
|
|
17
|
+
nodes += 1
|
|
18
|
+
if depth > 64 or nodes > 65536:
|
|
19
|
+
raise ValueError("bounded")
|
|
20
|
+
white()
|
|
21
|
+
start = index
|
|
22
|
+
if text[index] == '"':
|
|
23
|
+
value, index = decoder.raw_decode(text, index)
|
|
24
|
+
strings[path] = (start, index, value)
|
|
25
|
+
return value
|
|
26
|
+
if text[index] == "{":
|
|
27
|
+
index += 1
|
|
28
|
+
result = {}
|
|
29
|
+
white()
|
|
30
|
+
if text[index] == "}":
|
|
31
|
+
index += 1
|
|
32
|
+
return result
|
|
33
|
+
while True:
|
|
34
|
+
white()
|
|
35
|
+
key, index = decoder.raw_decode(text, index)
|
|
36
|
+
if type(key) is not str or key in result:
|
|
37
|
+
raise ValueError("duplicate")
|
|
38
|
+
white()
|
|
39
|
+
if text[index] != ":":
|
|
40
|
+
raise ValueError("colon")
|
|
41
|
+
index += 1
|
|
42
|
+
result[key] = walk((*path, key), depth + 1)
|
|
43
|
+
white()
|
|
44
|
+
end = text[index]
|
|
45
|
+
index += 1
|
|
46
|
+
if end == "}":
|
|
47
|
+
return result
|
|
48
|
+
if end != ",":
|
|
49
|
+
raise ValueError("comma")
|
|
50
|
+
if text[index] == "[":
|
|
51
|
+
index += 1
|
|
52
|
+
result = []
|
|
53
|
+
white()
|
|
54
|
+
if text[index] == "]":
|
|
55
|
+
index += 1
|
|
56
|
+
return result
|
|
57
|
+
while True:
|
|
58
|
+
result.append(walk((*path, len(result)), depth + 1))
|
|
59
|
+
white()
|
|
60
|
+
end = text[index]
|
|
61
|
+
index += 1
|
|
62
|
+
if end == "]":
|
|
63
|
+
return result
|
|
64
|
+
if end != ",":
|
|
65
|
+
raise ValueError("comma")
|
|
66
|
+
value, index = decoder.raw_decode(text, index)
|
|
67
|
+
return value
|
|
68
|
+
|
|
69
|
+
try:
|
|
70
|
+
value = walk(())
|
|
71
|
+
white()
|
|
72
|
+
return (value, strings) if index == len(text) else None
|
|
73
|
+
except (ValueError, IndexError, RecursionError):
|
|
74
|
+
return None
|
|
75
|
+
|
|
76
|
+
|
|
77
|
+
def patch(text, replacements):
|
|
78
|
+
end = len(text)
|
|
79
|
+
for (start, stop, original), replacement in sorted(replacements, reverse=True):
|
|
80
|
+
if start < 0 or stop > end or start >= stop or json.loads(text[start:stop]) != original:
|
|
81
|
+
return None
|
|
82
|
+
text = text[:start] + json.dumps(replacement, ensure_ascii=False) + text[stop:]
|
|
83
|
+
end = start
|
|
84
|
+
return text
|
|
@@ -0,0 +1,190 @@
|
|
|
1
|
+
"""Pull-driven response accounting for the pinned native provider SDK transport."""
|
|
2
|
+
from __future__ import annotations
|
|
3
|
+
|
|
4
|
+
import httpx2
|
|
5
|
+
import asyncio
|
|
6
|
+
import hashlib
|
|
7
|
+
import uuid
|
|
8
|
+
|
|
9
|
+
from ._native import Attempt, owner
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
from ._usage import UsageReader
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class OpenAICall:
|
|
16
|
+
"""One prepared native operation and its observed physical HTTP attempts."""
|
|
17
|
+
def __init__(self, attempt, transport):
|
|
18
|
+
self.attempt, self.transport, self.attempt_count = attempt, transport, 0
|
|
19
|
+
|
|
20
|
+
def next_attempt(self, request):
|
|
21
|
+
original = self.attempt
|
|
22
|
+
attempt = original if self.attempt_count == 0 else Attempt(original.runtime, original.scope,
|
|
23
|
+
original.logical_call_id, str(uuid.uuid4()), optimization=original.optimization, plan_id=original.plan_id)
|
|
24
|
+
self.attempt_count += 1
|
|
25
|
+
try:
|
|
26
|
+
attempt.wire_sha256 = hashlib.sha256(request.content).hexdigest()
|
|
27
|
+
except httpx2.RequestNotRead:
|
|
28
|
+
pass
|
|
29
|
+
return attempt
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
class CavemanOpenAITransport(httpx2.BaseTransport):
|
|
33
|
+
"""Wrap an application-owned HTTPX2 transport before client construction.
|
|
34
|
+
|
|
35
|
+
Pass this same object as ``transport`` to ``with_caveman_openai``. Requests
|
|
36
|
+
outside that native wrapper pass through. The supplied transport retains its
|
|
37
|
+
connection pool, TLS/proxy settings, and close behavior; this adds no retries.
|
|
38
|
+
"""
|
|
39
|
+
def __init__(self, transport):
|
|
40
|
+
if not isinstance(transport, httpx2.BaseTransport):
|
|
41
|
+
raise TypeError("Expected an HTTPX2 BaseTransport")
|
|
42
|
+
self.transport = transport
|
|
43
|
+
|
|
44
|
+
def handle_request(self, request):
|
|
45
|
+
call = owner.get()
|
|
46
|
+
if not isinstance(call, OpenAICall) or call.transport is not self:
|
|
47
|
+
return self.transport.handle_request(request)
|
|
48
|
+
attempt = call.next_attempt(request)
|
|
49
|
+
attempt.observe("dispatch_intent")
|
|
50
|
+
token = owner.set(attempt)
|
|
51
|
+
try:
|
|
52
|
+
response = self.transport.handle_request(request)
|
|
53
|
+
observe_response(response, attempt)
|
|
54
|
+
return response
|
|
55
|
+
except BaseException:
|
|
56
|
+
attempt.observe("failed")
|
|
57
|
+
raise
|
|
58
|
+
finally:
|
|
59
|
+
owner.reset(token)
|
|
60
|
+
|
|
61
|
+
def close(self):
|
|
62
|
+
self.transport.close()
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
class CavemanAsyncOpenAITransport(httpx2.AsyncBaseTransport):
|
|
66
|
+
"""Async counterpart of CavemanOpenAITransport, using the native pool."""
|
|
67
|
+
def __init__(self, transport):
|
|
68
|
+
if not isinstance(transport, httpx2.AsyncBaseTransport):
|
|
69
|
+
raise TypeError("Expected an HTTPX2 AsyncBaseTransport")
|
|
70
|
+
self.transport = transport
|
|
71
|
+
|
|
72
|
+
async def handle_async_request(self, request):
|
|
73
|
+
call = owner.get()
|
|
74
|
+
if not isinstance(call, OpenAICall) or call.transport is not self:
|
|
75
|
+
return await self.transport.handle_async_request(request)
|
|
76
|
+
attempt = call.next_attempt(request)
|
|
77
|
+
attempt.observe("dispatch_intent")
|
|
78
|
+
token = owner.set(attempt)
|
|
79
|
+
try:
|
|
80
|
+
response = await self.transport.handle_async_request(request)
|
|
81
|
+
observe_response(response, attempt)
|
|
82
|
+
return response
|
|
83
|
+
except (asyncio.CancelledError, GeneratorExit):
|
|
84
|
+
attempt.observe("cancelled")
|
|
85
|
+
raise
|
|
86
|
+
except BaseException:
|
|
87
|
+
attempt.observe("failed")
|
|
88
|
+
raise
|
|
89
|
+
finally:
|
|
90
|
+
owner.reset(token)
|
|
91
|
+
|
|
92
|
+
async def aclose(self):
|
|
93
|
+
await self.transport.aclose()
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
class SyncObservedStream(httpx2.SyncByteStream):
|
|
97
|
+
def __init__(self, original, attempt, parser):
|
|
98
|
+
self.original, self.attempt, self.parser, self.ended = original, attempt, parser, False
|
|
99
|
+
|
|
100
|
+
def finish(self, event):
|
|
101
|
+
if not self.ended:
|
|
102
|
+
self.ended = True
|
|
103
|
+
self.attempt.observe(event, self.parser.finish() if event == "completed" else None)
|
|
104
|
+
|
|
105
|
+
def __iter__(self):
|
|
106
|
+
iterator = iter(self.original)
|
|
107
|
+
try:
|
|
108
|
+
while True:
|
|
109
|
+
token = owner.set(self.attempt)
|
|
110
|
+
try:
|
|
111
|
+
chunk = next(iterator)
|
|
112
|
+
except StopIteration:
|
|
113
|
+
self.finish("completed")
|
|
114
|
+
return
|
|
115
|
+
finally:
|
|
116
|
+
owner.reset(token)
|
|
117
|
+
self.parser.feed(chunk)
|
|
118
|
+
yield chunk
|
|
119
|
+
except GeneratorExit:
|
|
120
|
+
self.finish("completed" if self.parser.terminal else "cancelled")
|
|
121
|
+
raise
|
|
122
|
+
except BaseException:
|
|
123
|
+
self.finish("failed")
|
|
124
|
+
raise
|
|
125
|
+
|
|
126
|
+
def close(self):
|
|
127
|
+
try:
|
|
128
|
+
self.original.close()
|
|
129
|
+
finally:
|
|
130
|
+
self.finish("completed" if self.parser.terminal else "cancelled")
|
|
131
|
+
|
|
132
|
+
|
|
133
|
+
class AsyncObservedStream(httpx2.AsyncByteStream):
|
|
134
|
+
def __init__(self, original, attempt, parser):
|
|
135
|
+
self.original, self.attempt, self.parser, self.ended = original, attempt, parser, False
|
|
136
|
+
|
|
137
|
+
def finish(self, event):
|
|
138
|
+
if not self.ended:
|
|
139
|
+
self.ended = True
|
|
140
|
+
self.attempt.observe(event, self.parser.finish() if event == "completed" else None)
|
|
141
|
+
|
|
142
|
+
async def __aiter__(self):
|
|
143
|
+
iterator = self.original.__aiter__()
|
|
144
|
+
try:
|
|
145
|
+
while True:
|
|
146
|
+
token = owner.set(self.attempt)
|
|
147
|
+
try:
|
|
148
|
+
chunk = await anext(iterator)
|
|
149
|
+
except StopAsyncIteration:
|
|
150
|
+
self.finish("completed")
|
|
151
|
+
return
|
|
152
|
+
finally:
|
|
153
|
+
owner.reset(token)
|
|
154
|
+
self.parser.feed(chunk)
|
|
155
|
+
yield chunk
|
|
156
|
+
except GeneratorExit:
|
|
157
|
+
self.finish("completed" if self.parser.terminal else "cancelled")
|
|
158
|
+
raise
|
|
159
|
+
except asyncio.CancelledError:
|
|
160
|
+
self.finish("cancelled")
|
|
161
|
+
raise
|
|
162
|
+
except BaseException:
|
|
163
|
+
self.finish("failed")
|
|
164
|
+
raise
|
|
165
|
+
|
|
166
|
+
async def aclose(self):
|
|
167
|
+
try:
|
|
168
|
+
await self.original.aclose()
|
|
169
|
+
finally:
|
|
170
|
+
self.finish("completed" if self.parser.terminal else "cancelled")
|
|
171
|
+
|
|
172
|
+
|
|
173
|
+
def observe_response(response, attempt):
|
|
174
|
+
if not isinstance(response, httpx2.Response):
|
|
175
|
+
return
|
|
176
|
+
if response.status_code >= 400:
|
|
177
|
+
attempt.observe("failed")
|
|
178
|
+
return
|
|
179
|
+
content_type = response.headers.get("content-type", "")
|
|
180
|
+
if "json" not in content_type and "text/event-stream" not in content_type:
|
|
181
|
+
attempt.observe("completed")
|
|
182
|
+
return
|
|
183
|
+
parser = UsageReader("text/event-stream" in content_type)
|
|
184
|
+
if response.is_stream_consumed:
|
|
185
|
+
parser.feed(response.content)
|
|
186
|
+
attempt.observe("completed", parser.finish())
|
|
187
|
+
elif isinstance(response.stream, httpx2.SyncByteStream):
|
|
188
|
+
response.stream = SyncObservedStream(response.stream, attempt, parser)
|
|
189
|
+
elif isinstance(response.stream, httpx2.AsyncByteStream):
|
|
190
|
+
response.stream = AsyncObservedStream(response.stream, attempt, parser)
|
|
@@ -0,0 +1,292 @@
|
|
|
1
|
+
"""Native dictionary views; no provider-to-common-message round trip."""
|
|
2
|
+
from __future__ import annotations
|
|
3
|
+
|
|
4
|
+
import contextvars
|
|
5
|
+
import json
|
|
6
|
+
import math
|
|
7
|
+
import uuid
|
|
8
|
+
from dataclasses import dataclass
|
|
9
|
+
from typing import Any
|
|
10
|
+
|
|
11
|
+
from caveman_cloud.middleware import Adapter, Candidate, Scope, sha256
|
|
12
|
+
|
|
13
|
+
owner: contextvars.ContextVar[Attempt | None] = contextvars.ContextVar("caveman_middleware_owner", default=None)
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def plain(value: Any) -> bool:
|
|
17
|
+
return type(value) is dict
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
def manifest(items: list) -> list[dict] | None:
|
|
21
|
+
budget = 2 << 20
|
|
22
|
+
seen: set[int] = set()
|
|
23
|
+
|
|
24
|
+
def visit(value, depth=0):
|
|
25
|
+
nonlocal budget
|
|
26
|
+
if depth > 64 or budget < 0:
|
|
27
|
+
raise ValueError("bounded")
|
|
28
|
+
if type(value) is str:
|
|
29
|
+
budget -= len(value.encode("utf-8"))
|
|
30
|
+
elif value is None or type(value) in (bool, int):
|
|
31
|
+
budget -= 32
|
|
32
|
+
elif type(value) is float and math.isfinite(value):
|
|
33
|
+
budget -= 32
|
|
34
|
+
elif type(value) in (dict, list):
|
|
35
|
+
if id(value) in seen:
|
|
36
|
+
raise ValueError("cyclic")
|
|
37
|
+
seen.add(id(value))
|
|
38
|
+
for key, entry in (value.items() if type(value) is dict else enumerate(value)):
|
|
39
|
+
if type(value) is dict:
|
|
40
|
+
if type(key) is not str:
|
|
41
|
+
raise ValueError("opaque")
|
|
42
|
+
budget -= len(key.encode("utf-8"))
|
|
43
|
+
visit(entry, depth + 1)
|
|
44
|
+
seen.remove(id(value))
|
|
45
|
+
else:
|
|
46
|
+
raise ValueError("opaque")
|
|
47
|
+
|
|
48
|
+
try:
|
|
49
|
+
result = []
|
|
50
|
+
for i, item in enumerate(items):
|
|
51
|
+
visit(item)
|
|
52
|
+
if budget < 0:
|
|
53
|
+
return None
|
|
54
|
+
result.append({"id": f"message-{i}", "sha256": sha256(json.dumps(item, ensure_ascii=False, separators=(",", ":"), allow_nan=False))})
|
|
55
|
+
return result
|
|
56
|
+
except (TypeError, ValueError, RecursionError, UnicodeError):
|
|
57
|
+
return None
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def leaves(body: dict, protocol: str) -> tuple[list, list[tuple[tuple, str]]] | None:
|
|
61
|
+
found: list[tuple[tuple, str]] = []
|
|
62
|
+
calls, results = {}, {}
|
|
63
|
+
|
|
64
|
+
def only(value, keys):
|
|
65
|
+
return plain(value) and set(value).issubset(keys)
|
|
66
|
+
|
|
67
|
+
def call(identifier, name, position, valid):
|
|
68
|
+
if type(identifier) is str and identifier:
|
|
69
|
+
calls[identifier] = (name, position) if identifier not in calls and valid else None
|
|
70
|
+
|
|
71
|
+
def result(identifier):
|
|
72
|
+
if type(identifier) is str:
|
|
73
|
+
results[identifier] = results.get(identifier, 0) + 1
|
|
74
|
+
|
|
75
|
+
def matched(identifier, position, name=None):
|
|
76
|
+
source = calls.get(identifier) if type(identifier) is str else None
|
|
77
|
+
return bool(source and source[1] < position and source[0] != "caveman_retrieve"
|
|
78
|
+
and results.get(identifier) == 1 and (name is None or name == source[0]))
|
|
79
|
+
|
|
80
|
+
def text_parts(content, path, cache_control=False):
|
|
81
|
+
if type(content) is str:
|
|
82
|
+
found.append((path, content))
|
|
83
|
+
elif type(content) is list:
|
|
84
|
+
keys = {"type", "text", "cache_control"} if cache_control else {"type", "text"}
|
|
85
|
+
# A mixed/cited/unknown block contract protects the entire result.
|
|
86
|
+
if all(only(part, keys) and part.get("type") == "text" and type(part.get("text")) is str for part in content):
|
|
87
|
+
found.extend(((*path, i, "text"), part["text"]) for i, part in enumerate(content))
|
|
88
|
+
|
|
89
|
+
if protocol == "openai-chat" and type(body.get("messages")) is list:
|
|
90
|
+
messages = body["messages"]
|
|
91
|
+
for mi, message in enumerate(messages):
|
|
92
|
+
if not plain(message):
|
|
93
|
+
continue
|
|
94
|
+
if message.get("role") == "assistant" and type(message.get("tool_calls")) is list:
|
|
95
|
+
for item in message["tool_calls"]:
|
|
96
|
+
if not plain(item):
|
|
97
|
+
continue
|
|
98
|
+
function = item.get("function")
|
|
99
|
+
valid = (only(item, {"id", "type", "function", "index"}) and item.get("type") == "function"
|
|
100
|
+
and ("index" not in item or (type(item["index"]) is int and 0 <= item["index"] <= 2**53 - 1))
|
|
101
|
+
and only(function, {"name", "arguments"}) and type(function.get("name")) is str
|
|
102
|
+
and bool(function["name"]) and type(function.get("arguments")) is str)
|
|
103
|
+
call(item.get("id"), function.get("name") if plain(function) else None, mi, valid)
|
|
104
|
+
elif message.get("role") == "tool":
|
|
105
|
+
result(message.get("tool_call_id"))
|
|
106
|
+
for mi, message in enumerate(messages):
|
|
107
|
+
if (not only(message, {"role", "tool_call_id", "content", "name", "is_error", "cache_breakpoint"})
|
|
108
|
+
or message.get("role") != "tool" or message.get("is_error") not in (None, False)
|
|
109
|
+
or not matched(message.get("tool_call_id"), mi, message.get("name"))):
|
|
110
|
+
continue
|
|
111
|
+
text_parts(message.get("content"), ("messages", mi, "content"))
|
|
112
|
+
return messages, found
|
|
113
|
+
if protocol == "openai-responses" and type(body.get("input")) is list:
|
|
114
|
+
if body.get("previous_response_id") or body.get("conversation"):
|
|
115
|
+
return None
|
|
116
|
+
items = body["input"]
|
|
117
|
+
for i, item in enumerate(items):
|
|
118
|
+
if not plain(item):
|
|
119
|
+
continue
|
|
120
|
+
if item.get("type") == "function_call":
|
|
121
|
+
valid = (only(item, {"type", "call_id", "name", "arguments", "id", "status", "parsed_arguments", "caller", "namespace"})
|
|
122
|
+
and item.get("caller") is None and item.get("namespace") is None
|
|
123
|
+
and (item.get("parsed_arguments") is None or plain(item["parsed_arguments"]))
|
|
124
|
+
and type(item.get("name")) is str and bool(item["name"])
|
|
125
|
+
and type(item.get("arguments")) is str and item.get("status") in (None, "completed"))
|
|
126
|
+
call(item.get("call_id"), item.get("name"), i, valid)
|
|
127
|
+
elif item.get("type") == "function_call_output":
|
|
128
|
+
result(item.get("call_id"))
|
|
129
|
+
for i, item in enumerate(items):
|
|
130
|
+
if (only(item, {"type", "call_id", "output", "id", "status"}) and item.get("type") == "function_call_output"
|
|
131
|
+
and item.get("status") in (None, "completed") and matched(item.get("call_id"), i)
|
|
132
|
+
and type(item.get("output")) is str):
|
|
133
|
+
found.append((("input", i, "output"), item["output"]))
|
|
134
|
+
return items, found
|
|
135
|
+
if protocol == "anthropic-messages" and type(body.get("messages")) is list:
|
|
136
|
+
messages = body["messages"]
|
|
137
|
+
for mi, message in enumerate(messages):
|
|
138
|
+
if not plain(message) or type(message.get("content")) is not list:
|
|
139
|
+
continue
|
|
140
|
+
for part in message["content"]:
|
|
141
|
+
if not plain(part):
|
|
142
|
+
continue
|
|
143
|
+
if message.get("role") == "assistant" and part.get("type") == "tool_use":
|
|
144
|
+
valid = (only(part, {"type", "id", "name", "input", "cache_control"})
|
|
145
|
+
and type(part.get("name")) is str and bool(part["name"]) and plain(part.get("input")))
|
|
146
|
+
call(part.get("id"), part.get("name"), mi, valid)
|
|
147
|
+
elif part.get("type") == "tool_result":
|
|
148
|
+
result(part.get("tool_use_id"))
|
|
149
|
+
for mi, message in enumerate(messages):
|
|
150
|
+
if not plain(message) or message.get("role") != "user" or type(message.get("content")) is not list:
|
|
151
|
+
continue
|
|
152
|
+
for pi, part in enumerate(message["content"]):
|
|
153
|
+
if (not only(part, {"type", "tool_use_id", "content", "is_error", "cache_control"})
|
|
154
|
+
or part.get("type") != "tool_result" or part.get("is_error") not in (None, False)
|
|
155
|
+
or not matched(part.get("tool_use_id"), mi)):
|
|
156
|
+
continue
|
|
157
|
+
text_parts(part.get("content"), ("messages", mi, "content", pi, "content"), True)
|
|
158
|
+
return messages, found
|
|
159
|
+
if protocol == "google-genai" and type(body.get("contents")) is list:
|
|
160
|
+
for mi, message in enumerate(body["contents"]):
|
|
161
|
+
if not plain(message) or type(message.get("parts")) is not list:
|
|
162
|
+
continue
|
|
163
|
+
for pi, part in enumerate(message["parts"]):
|
|
164
|
+
response = part.get("functionResponse") if plain(part) else None
|
|
165
|
+
if (plain(response) and response.get("name") != "caveman_retrieve" and plain(response.get("response"))
|
|
166
|
+
and "error" not in response["response"] and type(response["response"].get("output")) is str):
|
|
167
|
+
found.append((("contents", mi, "parts", pi, "functionResponse", "response", "output"), response["response"]["output"]))
|
|
168
|
+
return body["contents"], found
|
|
169
|
+
return None
|
|
170
|
+
|
|
171
|
+
|
|
172
|
+
def replace_path(value: Any, path: tuple, text: str) -> Any:
|
|
173
|
+
if not path:
|
|
174
|
+
return text
|
|
175
|
+
clone = value.copy()
|
|
176
|
+
clone[path[0]] = replace_path(value[path[0]], path[1:], text)
|
|
177
|
+
return clone
|
|
178
|
+
|
|
179
|
+
|
|
180
|
+
def accepts_recovery(body, protocol, binding):
|
|
181
|
+
if binding is None or type(body.get("tools")) is not list:
|
|
182
|
+
return False
|
|
183
|
+
if (body.get("response_format") is not None or body.get("output_format") is not None
|
|
184
|
+
or (plain(body.get("output_config")) and body["output_config"].get("format") is not None)
|
|
185
|
+
or (protocol == "openai-responses" and plain(body.get("text")) and body["text"].get("format") is not None)):
|
|
186
|
+
return False
|
|
187
|
+
choice = body.get("tool_choice")
|
|
188
|
+
if choice is not None and choice != "auto" and not (plain(choice) and choice.get("type") == "auto"):
|
|
189
|
+
return False
|
|
190
|
+
tools = [t.get("function") if protocol == "openai-chat" and plain(t) else t for t in body["tools"]]
|
|
191
|
+
if any(not plain(tool) or type(tool.get("name")) is not str for tool in tools):
|
|
192
|
+
return False
|
|
193
|
+
if len({tool["name"] for tool in tools}) != len(tools):
|
|
194
|
+
return False
|
|
195
|
+
if protocol == "anthropic-messages" and any(
|
|
196
|
+
plain(message) and type(message.get("content")) is list and any(
|
|
197
|
+
plain(part) and part.get("type") in ("tool_removal", "tool_addition") for part in message["content"])
|
|
198
|
+
for message in body.get("messages", [])):
|
|
199
|
+
return False
|
|
200
|
+
matches = [t for t in tools if plain(t) and t.get("name") == binding.name]
|
|
201
|
+
return len(matches) == 1 and matches[0].get("description") == binding.description and matches[0].get("input_schema" if protocol == "anthropic-messages" else "parameters") == binding.input_schema
|
|
202
|
+
|
|
203
|
+
|
|
204
|
+
@dataclass
|
|
205
|
+
class Attempt:
|
|
206
|
+
runtime: Any
|
|
207
|
+
scope: Scope
|
|
208
|
+
logical_call_id: str
|
|
209
|
+
attempt_id: str
|
|
210
|
+
optimization: Any = None
|
|
211
|
+
wire_sha256: str | None = None
|
|
212
|
+
plan_id: str | None = None
|
|
213
|
+
passive: bool = False
|
|
214
|
+
reason: str = "no_candidate"
|
|
215
|
+
adapter: str | None = None
|
|
216
|
+
_reported_attempt_id: str | None = None
|
|
217
|
+
|
|
218
|
+
def observe(self, event, usage=None):
|
|
219
|
+
if event == "dispatch_intent" and self._reported_attempt_id != self.attempt_id:
|
|
220
|
+
self._reported_attempt_id = self.attempt_id
|
|
221
|
+
self.runtime.report(self.optimization, logical_call_id=self.logical_call_id, attempt_id=self.attempt_id,
|
|
222
|
+
reason=self.reason, adapter=self.adapter)
|
|
223
|
+
if self.passive or self.runtime.mode == "off":
|
|
224
|
+
return
|
|
225
|
+
self.runtime.observe_background({"schema_version": 1, "scope": self.scope.__dict__, "logical_call_id": self.logical_call_id,
|
|
226
|
+
"attempt_id": self.attempt_id, "event_kind": event,
|
|
227
|
+
"plan_id": self.plan_id or (self.optimization.plan["replacement_set_id"] if self.optimization and self.optimization.plan else None),
|
|
228
|
+
"usage": usage, "provider_request_sha256": self.wire_sha256})
|
|
229
|
+
|
|
230
|
+
|
|
231
|
+
class NativeSession:
|
|
232
|
+
def __init__(self, runtime, scope, *, adapter_id, framework_version, protocol, binding=None, overhead=None, logical_call_id=None, is_registered=None, passive_reason=None):
|
|
233
|
+
self.runtime, self.scope, self.protocol = runtime, scope, protocol
|
|
234
|
+
self.binding, self.overhead, self.logical_call_id = binding, overhead, logical_call_id
|
|
235
|
+
self.is_registered = is_registered
|
|
236
|
+
self.passive_reason = passive_reason
|
|
237
|
+
self.adapter = Adapter(adapter_id, "0.1.0", framework_version, protocol + "-native-v1")
|
|
238
|
+
|
|
239
|
+
def registered(self):
|
|
240
|
+
try:
|
|
241
|
+
return self.is_registered is None or self.is_registered() is True
|
|
242
|
+
except Exception:
|
|
243
|
+
return False
|
|
244
|
+
|
|
245
|
+
def options(self, body):
|
|
246
|
+
if owner.get() is not None or self.runtime.mode == "off" or self.passive_reason or not plain(body):
|
|
247
|
+
return None
|
|
248
|
+
selected = leaves(body, self.protocol)
|
|
249
|
+
if selected is None:
|
|
250
|
+
return None
|
|
251
|
+
context, selected_leaves = selected
|
|
252
|
+
context_manifest = manifest(context)
|
|
253
|
+
if context_manifest is None:
|
|
254
|
+
return None
|
|
255
|
+
attempt = Attempt(self.runtime, self.scope, self.logical_call_id or str(uuid.uuid4()), str(uuid.uuid4()), adapter=self.adapter.id)
|
|
256
|
+
binding = self.binding if self.registered() and self.runtime.owns_binding(self.binding, self.scope) and accepts_recovery(body, self.protocol, self.binding) else None
|
|
257
|
+
options = dict(scope=self.scope, adapter=self.adapter, candidates=[Candidate(id=f"leaf-{i}", source_id="/".join(map(str,path)), content=text) for i,(path,text) in enumerate(selected_leaves)],
|
|
258
|
+
manifest=context_manifest, model={"provider": self.adapter.id.removesuffix("-sdk"), "id": body["model"], "protocol": self.protocol} if type(body.get("model")) is str else None,
|
|
259
|
+
binding=binding, recovery_overhead_text=self.overhead, logical_call_id=attempt.logical_call_id, attempt_id=attempt.attempt_id)
|
|
260
|
+
return attempt, selected_leaves, options
|
|
261
|
+
|
|
262
|
+
def apply(self, body, state, outcome):
|
|
263
|
+
attempt, selected, options = state
|
|
264
|
+
attempt.optimization = outcome if not outcome.replacements else None
|
|
265
|
+
if options["binding"] is not None and (not self.registered() or
|
|
266
|
+
not self.runtime.owns_binding(options["binding"], self.scope) or
|
|
267
|
+
not accepts_recovery(body, self.protocol, options["binding"])):
|
|
268
|
+
attempt.reason = "recovery_unavailable"
|
|
269
|
+
return body, attempt
|
|
270
|
+
mapping = {f"leaf-{i}": path for i,(path,_) in enumerate(selected)}
|
|
271
|
+
if not all(r["segment_id"] in mapping for r in outcome.replacements):
|
|
272
|
+
attempt.reason = "invalid_plan"
|
|
273
|
+
return body, attempt
|
|
274
|
+
result = body
|
|
275
|
+
for replacement in outcome.replacements:
|
|
276
|
+
result = replace_path(result, mapping[replacement["segment_id"]], replacement["text"])
|
|
277
|
+
attempt.optimization = outcome
|
|
278
|
+
return result, attempt
|
|
279
|
+
|
|
280
|
+
def passive(self, body, reason=None):
|
|
281
|
+
if owner.get() is not None:
|
|
282
|
+
return body, None
|
|
283
|
+
return body, Attempt(self.runtime, self.scope, self.logical_call_id or str(uuid.uuid4()), str(uuid.uuid4()),
|
|
284
|
+
passive=True, reason=reason or self.passive_reason or "unsupported_shape", adapter=self.adapter.id)
|
|
285
|
+
|
|
286
|
+
def prepare(self, body):
|
|
287
|
+
state = self.options(body)
|
|
288
|
+
return self.passive(body) if state is None else self.apply(body, state, self.runtime.optimize(**state[2]))
|
|
289
|
+
|
|
290
|
+
async def prepare_async(self, body):
|
|
291
|
+
state = self.options(body)
|
|
292
|
+
return self.passive(body) if state is None else self.apply(body, state, await self.runtime.optimize(**state[2]))
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
"""Observe native iterators without keeping ownership in consumer code."""
|
|
2
|
+
from ._native import owner
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
def observe_iterator(iterator, attempt):
|
|
6
|
+
if attempt is None:
|
|
7
|
+
yield from iterator
|
|
8
|
+
return
|
|
9
|
+
attempt.observe("dispatch_intent")
|
|
10
|
+
last = None
|
|
11
|
+
try:
|
|
12
|
+
while True:
|
|
13
|
+
token = owner.set(attempt)
|
|
14
|
+
try:
|
|
15
|
+
value = next(iterator)
|
|
16
|
+
except StopIteration:
|
|
17
|
+
from ._usage import langchain_usage
|
|
18
|
+
attempt.observe("completed", langchain_usage(last))
|
|
19
|
+
return
|
|
20
|
+
finally:
|
|
21
|
+
owner.reset(token)
|
|
22
|
+
last = getattr(value, "usage_metadata", None) or last
|
|
23
|
+
yield value
|
|
24
|
+
except GeneratorExit:
|
|
25
|
+
attempt.observe("cancelled")
|
|
26
|
+
raise
|
|
27
|
+
except BaseException:
|
|
28
|
+
attempt.observe("failed")
|
|
29
|
+
raise
|
|
30
|
+
finally:
|
|
31
|
+
if hasattr(iterator, "close"):
|
|
32
|
+
iterator.close()
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
async def observe_async_iterator(iterator, attempt):
|
|
36
|
+
if attempt is None:
|
|
37
|
+
async for value in iterator:
|
|
38
|
+
yield value
|
|
39
|
+
return
|
|
40
|
+
attempt.observe("dispatch_intent")
|
|
41
|
+
last = None
|
|
42
|
+
try:
|
|
43
|
+
while True:
|
|
44
|
+
token = owner.set(attempt)
|
|
45
|
+
try:
|
|
46
|
+
value = await anext(iterator)
|
|
47
|
+
except StopAsyncIteration:
|
|
48
|
+
from ._usage import langchain_usage
|
|
49
|
+
attempt.observe("completed", langchain_usage(last))
|
|
50
|
+
return
|
|
51
|
+
finally:
|
|
52
|
+
owner.reset(token)
|
|
53
|
+
last = getattr(value, "usage_metadata", None) or last
|
|
54
|
+
yield value
|
|
55
|
+
except BaseException:
|
|
56
|
+
attempt.observe("cancelled")
|
|
57
|
+
raise
|
|
58
|
+
finally:
|
|
59
|
+
if hasattr(iterator, "aclose"):
|
|
60
|
+
await iterator.aclose()
|