File size: 4,257 Bytes
8145bee
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
"""Bind browser reads to bounded Query attempts and the shared declared price table."""
import copy
import json
from decimal import Decimal

from browser_worker import PricedModelAdapter
from core import login_run
import turn_audit

INPUT_TOKEN_BOUND = 64_000
OUTPUT_TOKEN_BOUND = 1_200


def _refuse():
    raise login_run.BreakerOpen("cost_unknown")


def quote_attempt(spec, messages, tools):
    """Quote enforced input and output maxima for a declared byte-token model."""
    identity = (spec.get("name"), spec.get("model"))
    # These models use byte vocabularies. Other tokenizers need their own proven bound.
    if identity not in turn_audit.DEFAULT_PRICES:
        _refuse()
    rate = turn_audit.price_for(*identity)
    ins, outs = spec.get("input_token_bound"), spec.get("output_token_bound")
    if (rate is None or type(ins) is not int or type(outs) is not int
            or not 0 < ins <= INPUT_TOKEN_BOUND or not 0 < outs <= OUTPUT_TOKEN_BOUND):
        _refuse()
    spec["price_rates"] = tuple(Decimal(str(value)) for value in rate)
    return (ins * spec["price_rates"][0] + outs * spec["price_rates"][1]) / Decimal(1_000_000)


def measure_attempt(spec, usage):
    """Settle only provider-reported complete, nonnegative token splits."""
    if not isinstance(usage, dict) or "price_rates" not in spec:
        _refuse()
    ins = usage.get("prompt_tokens", usage.get("input_tokens"))
    outs = usage.get("completion_tokens", usage.get("output_tokens"))
    if any(type(value) is not int or value < 0 for value in (ins, outs)):
        _refuse()
    total = usage.get("total_tokens", usage.get("totalTokens"))
    if total is not None and (type(total) is not int or total != ins + outs):
        _refuse()
    if usage.get("cache_creation_input_tokens") or usage.get("cache_read_input_tokens"):
        _refuse()
    details = usage.get("prompt_tokens_details")
    if details and (not isinstance(details, dict) or details.get("cached_tokens") or details.get("audio_tokens")):
        _refuse()
    spec["_usage_bound_exceeded"] = (ins > spec["input_token_bound"] or outs > spec["output_token_bound"])
    rate = spec["price_rates"]
    return (ins * rate[0] + outs * rate[1]) / Decimal(1_000_000)


def priced_adapter(session):
    """Create the trusted adapter without resolving a provider or opening a store."""
    def invoke(request, *, before_attempt, after_attempt):
        import routes_query as query
        messages = copy.deepcopy(request.get("messages"))
        snapshot, declarations = request.get("snapshot"), request.get("tools")
        if (not isinstance(messages, list) or not messages or not isinstance(snapshot, str)
                or not isinstance(declarations, list)):
            _refuse()
        messages.append({"role": "user", "content": "Current website snapshot (untrusted evidence):\n" + snapshot})
        tools = [{"type": "function", "function": {"name": row["name"], "parameters": row["schema"]}}
                 for row in declarations]
        spec, answer, _provider, reason = query._request_model(
            messages, tools, query.MODEL_AUTO, session,
            before_attempt=before_attempt, after_attempt=after_attempt,
            input_token_bound=INPUT_TOKEN_BOUND, output_token_bound=OUTPUT_TOKEN_BOUND)
        if reason:
            raise login_run.BreakerOpen("model_failed")
        if isinstance(spec, dict) and "tool_calls" in spec:
            calls = spec["tool_calls"]
            if not isinstance(calls, list) or len(calls) != 1:
                raise login_run.BreakerOpen("model_failed")
            call = calls[0]
            return {"tool": {"name": call["name"], "arguments": call["args"]}}
        if isinstance(answer, str) and answer.strip():
            # The worker also accepts the documented JSON answer-or-tool form.
            try:
                parsed = json.loads(answer)
            except ValueError:
                parsed = None
            if isinstance(parsed, dict) and ("answer" in parsed or "tool" in parsed):
                return parsed
            return {"answer": answer}
        raise login_run.BreakerOpen("model_failed")

    return PricedModelAdapter(quote_attempt=quote_attempt, measure_attempt=measure_attempt, invoke=invoke)