File size: 20,014 Bytes
8133df9
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
"""The Live tool: an answer newer than the last sync, the mirror with source changes overlaid by id."""

import copy
import datetime as dt
import json
import re
from contextlib import contextmanager, nullcontext

from core import external_tools, perm_scope, periods
import deps
import external_freshness


#: Rows per `rows` page. Paging only: every row of the window is reachable (rule 1).
PAGE = 200
_DAY = {"type": "string", "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$"}
WINDOW_SCHEMA = {
    "type": "object",
    "description": "Inclusive business days in the tenant's timezone. Omit for today.",
    "properties": {"date_from": copy.deepcopy(_DAY), "date_to": copy.deepcopy(_DAY)},
    "required": ["date_from", "date_to"], "additionalProperties": False,
}
_SQL_COLUMN = r"^{alias}\.([a-z_][a-z0-9_]*)$"
#: The day basis every answer states.
DAY_BASIS = "business day in the tenant's timezone"


class _Unavailable(Exception):
    """The live answer cannot run for this database. Carries a client error."""

    def __init__(self, status, code, message, details=None):
        super().__init__(message)
        self.error = deps.err(status, code, message, details=details)


def _arguments(ctx, args, action):
    if not isinstance(ctx, external_tools.ToolContext):
        raise deps.err(403, "tool_context_required", "Use the authenticated Live tool.")
    external_tools.validate_arguments(args, GROUP["actions"][action]["schema"])


def _limiter_store(session):
    runtime = session.runtime
    if all(callable(getattr(runtime, name, None)) for name in ("get", "revision", "update")):
        return runtime
    return None


def _source(session):
    """The tenant's bound Odoo source, refused when the runtime is another tenant's."""
    runtime = session.runtime
    if runtime.key != session.tenant:
        raise _Unavailable(403, "live_unavailable", "This tenant's data is not bound to this call.")
    runtime.assert_datastore_matches()
    source = runtime.odoo_source()
    if source is None:
        raise _Unavailable(409, "live_unavailable", "No source is connected for this database.",
                           {"cause": "no_source", "fix": "Connect the source under Connectors."})
    return source


@contextmanager
def _mirror_days(session):
    """Bind the stored business timezone without opening an Odoo connection."""
    from core import odoo
    from routes_keychain import stored_business_tz

    with odoo.tenant_scope(session.tenant):
        odoo._ctx()['business_tz'] = stored_business_tz(session.runtime)
        yield


def _binding(database):
    """`(mirror table, alias, definition SQL, spec)` for a database served from one synced table."""
    import routes_odoo_tables

    spec = routes_odoo_tables._sources().get(database)
    if not spec:
        raise _Unavailable(404, "live_unavailable", "This database has no live source.",
                           {"cause": "no_live_source", "fix": "Ask about a database a connector syncs."})
    identity = str(spec.get("id") or "")
    alias = identity.split(".")[0] if re.fullmatch(r"[a-z_]+\.id", identity) else None
    table = (spec.get("tables") or {}).get(alias) if alias else spec.get("table")
    alias = alias or table
    if not table or not alias:
        raise _Unavailable(409, "live_unavailable", "This database is not served from one synced table.",
                           {"cause": "unsupported_database", "fix": "Read this database from the mirror."})
    return table, alias, str(spec.get("where") or ""), spec


def _projection(spec, alias, keys):
    """`project(row)` mapping a mirror row to the database's field keys a plain column binds."""
    pattern = re.compile(_SQL_COLUMN.format(alias=re.escape(alias)))
    days = set(spec.get("business_days") or ())
    plan = {}
    for key, binding in (spec.get("cols") or {}).items():
        found = pattern.match(str(binding[0]).strip()) if key in keys else None
        if found:
            plan[key] = (found.group(1), binding[1], key in days)
        elif key in keys and re.fullmatch(r'"?[a-z_][a-z0-9_]*"?', str(binding[0]).strip()):
            plan[key] = (str(binding[0]).strip().strip('"'), binding[1], key in days)

    def project(row):
        out = {}
        for key, (column, convert, business_day) in plan.items():
            value = row.get(column)
            if business_day:
                day = periods.business_day(value)
                out[key] = day.isoformat() if day else ""
            else:
                try:
                    out[key] = convert(value)
                except (TypeError, ValueError):
                    out[key] = None
        return out

    return plan, project


def _fields(ctx, database):
    """The caller's visible fields of `database`, after the field wall."""
    session = ctx.session
    ctx.describe_database(database)
    snapshot = deps.assistant_read_scope(session, database, mode="schema")
    if snapshot.get("database") != database or not snapshot.get("permission_scope_applied") \
            or not snapshot.get("fields"):
        raise _Unavailable(403, "live_unavailable", "You cannot read this database.")
    return perm_scope.visible_fields(list(snapshot["fields"]), session.user, database,
                                     st=session.runtime)


def _windows(args):
    """`(window, prior window or None, grain, rule)` under the shared YoY rule."""
    from tool_groups import metrics

    today = periods.today().isoformat()
    sent = args.get("window") or {"date_from": today, "date_to": today}
    window = {"date_from": sent["date_from"], "date_to": sent["date_to"]}
    try:
        days = (dt.date.fromisoformat(window["date_to"]) - dt.date.fromisoformat(window["date_from"])).days + 1
    except ValueError:
        days = 0
    if days < 1:
        raise deps.err(400, "live_window_invalid", "The window needs a start day on or before its end day.")
    if days not in (1, 7) and args.get("compare") != "yoy":
        return window, None, None, None
    grain = metrics._compare_grain({"name": "date_range", **window})
    prior, rule = metrics._prior_window({"name": "date_range", **window}, grain)
    return window, {"date_from": prior["date_from"], "date_to": prior["date_to"]}, grain, rule


def _summary(entry):
    live = entry.get("live")
    return {"live_value": live["value"] if live else None, "live_rows": live["rows"] if live else None,
            "screen_value": entry["screen"]["value"], "screen_rows": entry["screen"]["rows"],
            "difference": entry.get("difference")}


def _observe(ctx, args, action):
    """Run one windowed live answer and shape the shared summary."""
    from core import connector_spec
    from harness import filter_eval, filter_sql, live_read, semantic

    _arguments(ctx, args, action)
    session = ctx.session
    database = args["database"]
    try:
        if session.runtime.key != session.tenant:
            raise _Unavailable(403, "live_unavailable", "This tenant's data is not bound to this call.")
        session.runtime.assert_datastore_matches()
        table, alias, where, spec = _binding(database)
        connector, _table, mode = live_read.resolve_table(table)
        if connector == 'meta':
            import routes_odoo_tables
            cur = routes_odoo_tables._table_cursor(session.runtime, database)
            try:
                spec = routes_odoo_tables._meta_source(cur, database) or spec
            finally:
                cur.close()
        fields = _fields(ctx, database)
        visible = [f["key"] for f in fields if isinstance(f, dict) and f.get("key")]
        plan, project = _projection(spec, alias, set(visible))
        date_field = args.get("date_field") or next(iter(spec.get("business_days") or ()), None)
        if date_field is None and connector == 'meta':
            from harness import meta_store
            if table == meta_store.INSIGHTS_TABLE:
                date_field = 'date_start'
        if date_field is not None and date_field not in plan:
            raise _Unavailable(400, "live_field_invalid", "Name a visible date field of this database.",
                               {"cause": "date_field", "fix": "Send date_field from describe_database."})
        measure = args.get("measure")
        generic = mode.mode != connector_spec.LIVE_CURSOR or bool(args.get('filters'))
        bound = set(spec.get('cols') or {}) if generic else set(plan)
        if measure is not None and measure not in bound.intersection(visible):
            raise _Unavailable(400, "live_field_invalid", "Name a visible number field to total.",
                               {"field": measure, "cause": "measure",
                                "fix": "Send measure from describe_database."})
        numeric = filter_eval.NUMERIC_TYPES | filter_sql.NUMERIC_TYPES | {'number', 'float'}
        if measure is not None and next(f for f in fields if f['key'] == measure).get('type') not in numeric:
            raise _Unavailable(400, "live_field_invalid", "The measure must be a number field.",
                               {"field": measure, "cause": "non_numeric_measure",
                                "fix": "Choose a visible number field from describe_database."})
        store = _limiter_store(session)
        if store is None:
            raise _Unavailable(409, "live_unavailable", "This workspace has no live call limiter.",
                               {"cause": "no_limiter", "fix": "Answer from the mirror."})
        source = _source(session) if connector == 'odoo' and mode.mode != connector_spec.LIVE_NONE else None
        with semantic.tenant_context(session.runtime) if source else nullcontext(), \
                source._bound() if source else _mirror_days(session):
            if date_field is None:
                if args.get('window') or args.get('compare'):
                    raise _Unavailable(400, "live_field_invalid", "This database has no default date field.",
                                       {"cause": "date_field", "fix": "Omit window and compare for a current slice."})
                window, prior, grain, rule = None, None, None, None
            else:
                window, prior, grain, rule = _windows(args)
            windows = {"current": (window["date_from"], window["date_to"]) if window else (None, None)}
            if prior:
                windows["prior"] = (prior["date_from"], prior["date_to"])
            column, _convert, instants = plan[date_field] if date_field else (None, None, False)
            wall = {"user": session.user, "database": database, "fields": fields, "st": session.runtime}
            extra = {}
            if generic:
                import routes_odoo_tables
                nodes = args.get('filters') or []
                columns = routes_odoo_tables._filter_columns(spec, fields)
                named = routes_odoo_tables._leaf_cols(nodes)
                if not named <= set(visible).intersection(columns):
                    raise _Unavailable(400, "live_field_invalid", "A filter needs a visible bound field.",
                                       {"cause": "filter_field", "fix": "Choose fields from describe_database."})
                try:
                    predicate = filter_sql.compile_filter_tree(nodes, columns=columns, today=periods.today())
                except ValueError:
                    raise _Unavailable(400, "live_filter_invalid", "This filter cannot answer at source row grain.",
                                       {"cause": "unsupported_filter", "fix": "Use a comparison on a source field."}) from None
                if nodes and (predicate is None or predicate.uses_aggregate or predicate.columns_used != named):
                    raise _Unavailable(400, "live_filter_invalid", "This filter cannot answer at source row grain.",
                                       {"cause": "unsupported_filter", "fix": "Use an active comparison on a source field."})
                domain = []
                if mode.mode == connector_spec.LIVE_SLICE:
                    operators = {'eq': '=', 'neq': '!=', 'gt': '>', 'gte': '>=', 'lt': '<', 'lte': '<=',
                                 'isAnyOf': 'in', 'isNoneOf': 'not in'}
                    for node in nodes:
                        key, op = node.get('colId'), node.get('op')
                        if key not in plan or op not in operators or node.get('rhs'):
                            continue
                        # Identity filters bound the source read without changing display rounding or text matching.
                        filter_column = plan[key][0]
                        if filter_column != 'id' and not filter_column.endswith('_id'):
                            continue
                        value = node.get('values', node.get('value'))
                        convert = plan[key][1]
                        try:
                            value = [convert(v) for v in value] if isinstance(value, list) else convert(value)
                        except (TypeError, ValueError):
                            raise _Unavailable(400, "live_filter_invalid", "The slice filter has an invalid value.",
                                               {"field": key, "cause": "filter_value",
                                                "fix": "Use a value of the field's declared type."}) from None
                        domain.append((filter_column, operators[op], value))
                    if not domain:
                        raise _Unavailable(400, "live_filter_invalid", "A current slice needs a source filter.",
                                           {"cause": "unbounded_slice", "fix": "Filter product_id for one SKU."})
                    live_read.slice_domain(live_read.datastore.ENTITIES[table], domain)
                definition = copy.copy(spec)
                definition['cols'] = dict(spec['cols'])
                if date_field:
                    definition['cols'][live_read._WINDOW_KEY] = (spec['cols'][date_field][0], lambda v: v)
                keys = set(visible) | {live_read._WINDOW_KEY}
                extra = {'definition': definition, 'domain': domain,
                         'filters': {'conj': 'and', 'nodes': nodes} if nodes else None}
                project = keys
            answer = live_read.window_answer(
                table, store, alias=alias, where=where, date_column=column, instants=instants,
                windows=windows, project=project, wall=wall, measure=measure,
                tenant_key=session.runtime.key, caller="live." + action, **extra)
    except _Unavailable as exc:
        raise exc.error from None
    except live_read.LiveReadError as exc:
        raise deps.err(409, "live_unavailable", exc.message, details=exc.as_dict()) from None
    fact = (external_freshness.snapshot(session, [database]) or {}).get(database) or {}
    current = answer["windows"]["current"]
    result = {"database": database, "mode": mode.mode, "measure": measure, "date_field": date_field,
              "day_basis": DAY_BASIS if window else None, "window": window, "served": answer["served"],
              **_summary(current),
              "last_sync": fact.get("source_synced_at"), "source_sync": fact.get("source_sync"),
              "delta": {"read": answer["delta"], "replaced": answer["replaced"], "added": answer["added"]}}
    if answer["limit_refusal"]:
        result["limit_refusal"] = answer["limit_refusal"]
    if answer["live_unavailable"]:
        result["live_unavailable"] = answer["live_unavailable"]
    if prior:
        result.update({"compare": "yoy", "compare_rule": rule, "compare_grain": grain,
                       "prior": {"window": prior, **_summary(answer["windows"]["prior"])}})
    return result, answer["rows"]["current"], visible


def answer(ctx, args):
    """Total or count a database window or current slice with its screen value and difference."""
    result, _rows, _visible = _observe(ctx, args, "answer")
    return result


def rows(ctx, args):
    """Read one page of the scoped live or mirror slice."""
    result, found, visible = _observe(ctx, args, "rows")
    start = int(args.get("cursor") or 0)
    page = [{key: row.get(key) for key in visible if key in row} for row in found[start:start + PAGE]]
    nxt = start + PAGE if start + PAGE < len(found) else None
    return {**result, "rows": page, "row_count": len(found), "next_cursor": nxt}


def _action(handler, extra=None):
    properties = {
        "database": {"type": "string", "minLength": 1,
                     "description": "Database key from table.list_databases."},
        "measure": {"type": "string", "minLength": 1,
                    "description": "Number field key to total. Omit to count rows."},
        "date_field": {"type": "string", "minLength": 1,
                       "description": "Date field key the window applies to. Omit for the default."},
        "window": copy.deepcopy(WINDOW_SCHEMA),
        "filters": {"type": "array", "items": external_tools._query_filter_node(depth=3, allow_link=False),
                    "description": "AND filters in the table vocabulary. For current stock, filter product_id for one SKU."},
        "compare": {"type": "string", "enum": ["yoy"],
                    "description": "Add the prior year window for any window."},
        **(extra or {}),
    }
    return {"read": True, "destructive": False, "confirm": False,
            "schema": {"type": "object", "description": handler.__doc__, "properties": properties,
                       "required": ["database"], "additionalProperties": False},
            "handler": handler}


GROUP = {
    "name": "live", "title": "Live",
    "guide": "Call live only when the question needs data newer than the last sync, such as today's "
             "orders. Otherwise read table. Live follows the connector's declared mode: source changes "
             "overlaid on the mirror by id, a bounded current slice, a live API, or the mirror with "
             "the reason no live read exists. It never updates mirrored rows and screens keep the mirror. "
             "Answer requires database and returns live_value, screen_value, difference and last_sync. "
             "Measure totals a number field, else rows are counted. The window is business days in the "
             "tenant's timezone and defaults to today for a dated database. Current slices need "
             "filters and can omit the date field and window. A one day or seven day window adds prior under "
             "compare_rule, the same weekday 364 days back. Rows returns the window's rows in pages. "
             "State the screen and live values and their difference. Over the live call limit the mirror "
             "answers, with limit_refusal naming the cause, next allowed time and fix.",
    "actions": {"answer": _action(answer),
                "rows": _action(rows, {"cursor": {"type": "integer", "minimum": 0,
                                                  "description": "next_cursor from the previous page."}})},
}

_INTENT = {"type": "string", "minLength": 1, "maxLength": 500}
LOOPY_SCHEMA = {"type": "object", "properties": {"action": {"type": "string", "enum": sorted(GROUP["actions"])},
                                                 "arguments": {"type": "object"},
                                                 "intent": copy.deepcopy(_INTENT)},
                "required": ["action"], "additionalProperties": False}


def loopy(session, args):
    """Serve the Assistant's Live group through the same MCP admission and dispatcher."""
    from routes_external import _dispatch_mcp
    reply = _dispatch_mcp({"jsonrpc": "2.0", "id": "loopy-live", "method": "tools/call",
                           "params": {"name": "live", "arguments": args}}, session)
    return json.loads(reply["result"]["content"][0]["text"])


TOOLS = [{"name": "live", "schema": {**LOOPY_SCHEMA, "description": GROUP["guide"]},
          "fn": loopy, "effect": "read"}]