"""SANDBOX generator: splice each of the 51 trie-fill injections into its assigned host conversation as a LATER turn (the injected row's history embeds the host's own prior tool turn, grounded to the host's customer). Non-destructive: host rows are NOT edited; we only ADD injected rows. Everything writes under temp/injection_sandbox/out. Reuses the proven grounded call assembly + replay verification from scripts/_gen_injections2.py. Run: python -u temp/injection_sandbox/gen_merged.py """ from __future__ import annotations import json import random import re import sys from collections import Counter from pathlib import Path ROOT = Path(__file__).resolve().parents[2] SAND = Path(__file__).resolve().parent sys.path.insert(0, str(ROOT)) sys.path.insert(0, str(ROOT / "systemUpgrade" / "executor")) import scripts._gen_injections2 as G # noqa: E402 from fake_state import EpisodeState # noqa: E402 from fake_tools import TOOLS # noqa: E402 DATA = SAND / "data" OUT = SAND / "out" OUT.mkdir(parents=True, exist_ok=True) # use the SANDBOX (clonable) free-running catalog for all grounding/replay CATALOG = json.load(open(DATA / "catalog.json", encoding="utf-8")) G.CATALOG = CATALOG RND = random.Random(1234) def hq_variant(leaf, on): """Humanized LATER-turn query. The customer is already authenticated in the host turn, so a real person would NOT restate email / name / ZIP or say 'look me up'. Phrase as a natural follow-up; keep the order-number literal (retrieval signal); no em dashes.""" V = { "schedule_delivery": [ f"Also, could you set delivery for {on} to next Tuesday?", f"One more thing, can we schedule {on} to arrive on the 14th?", f"While you're in there, I'd like {on} delivered next Tuesday if that works.", ], "request_gift_receipt": [ f"Oh, and could I get a gift receipt for {on}? It's a present.", f"Also, {on} is a gift, so a gift receipt would be great.", f"Could you include a gift receipt with {on}? It's for my sister.", ], "get_wishlist": [ "Also, can you remind me what's still on my wishlist?", "While I've got you, what did I have saved on my wishlist again?", "Oh, and what's left on my wishlist? I keep forgetting.", ], "get_order_invoice": [ f"Could you also send me the invoice for {on}? I need it for expenses.", f"One more thing, can I get the itemized invoice for {on}?", f"Also, I need the invoice for {on} for my records.", ], "redeem_loyalty_points": [ "Also, I'd like to cash in some of my loyalty points for credit.", "While we're at it, can I redeem a few hundred points?", "Oh, and can I put some loyalty points toward store credit?", ], "reorder_previous_order": [ f"Also, could you just reorder everything from {on}? Same as before.", f"One more thing, can we duplicate order {on}? I loved that batch.", f"While you're in there, could you reorder {on} for me?", ], "apply_gift_card": [ f"Also, I've got a gift card I'd like to put toward {on}.", f"Oh, can we apply my gift card to {on}?", f"While we're at it, please use my gift card on {on}.", ], "get_shipping_options": [ f"Also, what are the shipping options for {on}?", f"One more thing, what delivery choices do I have for {on}?", f"While you're there, can you tell me the shipping options on {on}?", ], "subscribe_to_restock_alert": [ f"Could you swap the out-of-stock item on {on}, and let me know when the original is back?", f"Please change that item on {on}, and sign me up for a restock alert on the old one.", f"Can we modify {on} to swap that item, and ping me when it restocks?", ], "file_shipping_insurance_claim": [ f"Also, {on} arrived damaged, can I file an insurance claim on it?", f"One more thing, I need to file a shipping insurance claim for {on}. It came banged up.", ], "request_price_match": [ f"Also, I saw an item from {on} cheaper elsewhere, can you price match it?", f"One more thing, can you price match something on {on}? Found it for less online.", ], "get_store_credit_balance": [ "Also, what's my store credit balance right now?", "Oh, and how much store credit do I have left?", ], "set_delivery_instructions": [ f"Also, can you add a note to leave {on} with the doorman?", f"One more thing, please have {on} left with the front desk.", ], "upgrade_shipping_speed": [ f"Also, can you bump {on} to express if it hasn't shipped yet?", f"One more thing, could you upgrade {on} to overnight?", ], } return RND.choice(V[leaf]) CONFIRM = [ "All set, anything else I can help with?", "Done. Let me know if you need more.", "Taken care of. What else can I do?", "That's handled. Anything further?", ] def parse(o): try: return json.loads(o) if isinstance(o, str) and o.strip().startswith("{") else None except json.JSONDecodeError: return None def host_customer(host, a): """Reconstruct the host's customer + order dicts, backed by the assignment.""" ods = {} ud = None for c in host["calls"]: o = parse(c.get("output")) if c["name"] == "get_user_details" and o and o.get("user_id"): ud = o if c["name"] == "get_order_details" and o and o.get("order_id"): ods[o["order_id"]] = o user_details = { "user_id": a["uid"], "email": a["email"], "name": a.get("name") or (ud or {}).get("name") or {"first_name": "Alex", "last_name": "Kim"}, "address": (ud or {}).get("address") or {"zip": a.get("zip", "10001")}, "orders": list(ods), } return {"uid": a["uid"], "email": a["email"], "user_details": user_details, "orders": ods} OPEN_LEAVES = {"schedule_delivery", "set_delivery_instructions", "get_shipping_options", "upgrade_shipping_speed", "modify_pending_order_items"} def order_ids_for(a, u): need = a["prefix"].count("get_order_details") if a["node"] == "N4" and a.get("n4_orders"): ids = [o for o in a["n4_orders"] if o in u["orders"]] or list(u["orders"]) elif a.get("grounded_order") and a["grounded_order"] in u["orders"]: ids = [a["grounded_order"]] + [o for o in u["orders"] if o != a["grounded_order"]] else: ids = list(u["orders"]) # For open-required ops, ground on the most-open order the host actually has: # pending/processing first, then shipped (still pre-delivery), then delivered. if a["node"] != "N4" and (a["leaf"] in OPEN_LEAVES or any(t in OPEN_LEAVES for t in a["prefix"])): def rank(oid): st = str((u["orders"].get(oid) or {}).get("status", "")).lower() if st in ("pending", "processing", "open", "pending (modified)"): return 0 return 1 if st == "shipped" else 2 ids = sorted(ids, key=rank) if not ids: ids = ["#W0000000"] while len(ids) < max(1, need): ids.append(ids[0]) return ids # ---- embedded-host humanization (copy-only; canonical host rows untouched) ---- # Targets the two dominant C3 tells in host turns while preserving EVERY DB # literal (order #, item id, price, quoted gift message, date, email, ZIP): # T1 scripted meta preamble ("Review my recent orders, then ...") # T2 trailing auth boilerplate ("... Name is X, ZIP 12345.") when that same # name/ZIP/email already appears earlier in the conversation (pure dedupe) # T3 assistant em/hyphen dashes ("Sure - let me ...") -> comma _PREAMBLE = [ re.compile(r"^\s*review my [\w ]{0,32}orders,\s*then\s+", re.I), re.compile(r"^\s*review my [\w ]{0,32}orders and\s+", re.I), re.compile(r"^\s*review my [\w ]{0,32}orders:\s*", re.I), re.compile(r"^\s*look at my [\w ]{0,32}orders:\s+", re.I), re.compile(r"^\s*can you look over my [\w ]{0,32}orders\?\s+", re.I), re.compile(r"^\s*across (?:my )?[\w ]{0,32}orders:\s+", re.I), ] _TRAIL_NAMEZIP = re.compile( r"\s*(?:my name is|name is)\s+([A-Za-z]+(?:\s+[A-Za-z]+)?),?\s*" r"(?:and\s+(?:my\s+)?)?zip(?:\s+is|\s+code\s+is|:)?\s*(\d{5})\.?\s*$", re.I) _TRAIL_EMAIL = re.compile(r"\s*my email is\s+([^\s,]+@[^\s,]+?)\.?\s*$", re.I) def _cap(s): return s[:1].upper() + s[1:] if s else s def humanize_host_query(q, history_text): for pat in _PREAMBLE: m = pat.match(q) if m: q = _cap(q[m.end():].lstrip()) break m = _TRAIL_NAMEZIP.search(q) if m and (m.group(1) in history_text and m.group(2) in history_text): q = q[:m.start()].rstrip() if q and q[-1] not in ".!?": q += "." m = _TRAIL_EMAIL.search(q) if m and m.group(1) in history_text: q = q[:m.start()].rstrip() if q and q[-1] not in ".!?": q += "." return q def _dedash(s): if not s: return s return re.sub(r"\s+[-\u2013\u2014]\s+", ", ", s) def embed_host_turn(host): """host history (small talk) + the host's own request rendered as a prior tool turn (confuser-style encoding) + a confirmation. The embedded copy is lightly humanized (preamble/auth-dedupe/dash cleanup); canonical host row is not modified.""" h = [dict(m) for m in (host.get("history") or [])] for m in h: # T3: clean assistant dashes if m.get("role") == "assistant" and m.get("content"): m["content"] = _dedash(m["content"]) history_text = " ".join((m.get("content") or "") for m in h) q = (host.get("query") or host.get("retrieval_text") or "").strip() q = humanize_host_query(q, history_text) # T1 + T2 h.append({"role": "user", "content": q, "tool_calls": [], "tool_call_id": None}) tcs = [{"name": c["name"], "arguments": c.get("arguments", {}), "output": c.get("output"), "reasoning": c.get("reasoning", "")} for c in host["calls"]] h.append({"role": "assistant", "content": None, "tool_calls": tcs, "tool_call_id": None}) for c in host["calls"]: h.append({"role": "tool", "content": c.get("output"), "tool_calls": [], "tool_call_id": None}) h.append({"role": "assistant", "content": _dedash(RND.choice(CONFIRM)), "tool_calls": [], "tool_call_id": None}) return h def history_tool_calls(host): """Tool calls embedded in the host's own history (auth/reads retained earlier).""" out = [] for m in (host.get("history") or []): for tc in (m.get("tool_calls") or []): out.append({"name": tc.get("name"), "arguments": tc.get("arguments", {}), "output": tc.get("output")}) return out # ------------------------------------------------ leaf/host value reconciliation def reconcile_leaf_with_host(calls, host): """If the injected leaf reads an entity the host turn already established, copy the host's recorded output verbatim so the same customer yields the same value at the conversation level (and the row still reproduces in isolation).""" leaf = calls[-1] n = leaf["name"] SELF = {"get_order_invoice", "get_shipping_options", "get_wishlist", "get_store_credit_balance"} if n not in SELF: return calls, None a = leaf.get("arguments", {}) ent = ("#" + str(a["order_id"]).lstrip("#").upper()) if a.get("order_id") else a.get("user_id") def _ent(c): aa = c.get("arguments", {}) return ("#" + str(aa["order_id"]).lstrip("#").upper()) if aa.get("order_id") else aa.get("user_id") for hc in host["calls"]: if hc["name"] == n and _ent(hc) == ent and hc.get("output") is not None: leaf["output"] = hc["output"] return calls, (n, ent) return calls, None # ------------------------------------------------ conversation-level state check def _ref_ids(call): a = call.get("arguments", {}) or {} out = {} for k in ("user_id", "order_id", "gift_card_id"): if a.get(k): out[k] = a[k] for k in ("item_id",): if a.get(k): out.setdefault("item_ids", []).append(a[k]) for k in ("item_ids", "new_item_ids"): for v in (a.get(k) or []): out.setdefault("item_ids", []).append(v) return out def _establish(call, users, orders, items, cards): n = call["name"] raw = call.get("output") o = parse(raw) if n.startswith("find_user_id"): uid = raw.strip().strip('"') if isinstance(raw, str) else None if uid and "_" in uid: users.add(uid) elif n == "get_user_details" and o: if o.get("user_id"): users.add(o["user_id"]) for oid in (o.get("orders") or []): orders.add("#" + str(oid).lstrip("#").upper()) elif n == "get_order_details" and o: if o.get("order_id"): orders.add("#" + str(o["order_id"]).lstrip("#").upper()) for it in (o.get("items") or []): if it.get("item_id"): items.add(str(it["item_id"])) elif n == "get_gift_card_balance" and o and o.get("gift_card_id"): cards.add(str(o["gift_card_id"])) elif n == "get_wishlist" and o: for it in (o.get("items") or []): if isinstance(it, dict) and it.get("item_id"): items.add(str(it["item_id"])) def conversation_state_check(seq_calls, catalog, hist_calls=()): """Temporal grounding (no forward/unmarked refs) + output reproduction over the whole merged conversation. ``hist_calls`` are tool calls from the host's history (auth retained earlier), which pre-establish entities. Returns (forward_refs, io_mismatches).""" cat_orders = {"#" + str(o).lstrip("#").upper() for o in catalog.get("order_balances", {})} cat_cards = {str(c) for c in catalog.get("gift_card_balances", {})} users, orders, items, cards = set(), set(cat_orders), set(), set(cat_cards) for hc in hist_calls: # entities established in host history _establish(hc, users, orders, items, cards) fwd = [] for i, c in enumerate(seq_calls): refs = _ref_ids(c) # user_id must be established, unless this call itself establishes it # (find_user_id_* mints it; get_user_details is the auth-retained read). if (refs.get("user_id") and refs["user_id"] not in users and not c["name"].startswith("find_user_id") and c["name"] != "get_user_details"): fwd.append((i, c["name"], "user_id", refs["user_id"])) if refs.get("order_id"): oid = "#" + str(refs["order_id"]).lstrip("#").upper() if oid not in orders and c["name"] != "get_order_details": fwd.append((i, c["name"], "order_id", refs["order_id"])) if refs.get("gift_card_id") and str(refs["gift_card_id"]) not in cards: fwd.append((i, c["name"], "gift_card_id", refs["gift_card_id"])) _establish(c, users, orders, items, cards) # I/O reproduction over the merged sequence (progressive seed) s = EpisodeState.from_trajectory({"calls": seq_calls}, catalog) io = [] for c in seq_calls: n = c["name"] if n not in TOOLS: continue got = TOOLS[n](s, c.get("arguments", {})) rec = parse(c.get("output")) if n in G.FIND: exp = (c.get("output") or "").strip().strip('"') if got != exp: io.append((n, "uid", got, exp)) continue if not isinstance(rec, dict): continue if n in G.FULLMATCH: if got != rec: io.append((n, "dict-diff")) continue keys = G.CHECK.get(n, []) if any(got.get(k) is None and rec.get(k) is not None for k in keys): continue def _eq(k): g, rv = got.get(k), rec.get(k) if k == "status" and isinstance(g, str) and isinstance(rv, str): return g.replace(" ", "_") == rv.replace(" ", "_") return g == rv miss = [k for k in keys if not _eq(k)] if miss: io.append((n, {k: (got.get(k), rec.get(k)) for k in miss})) return fwd, io # ------------------------------------------------------------------------- main def main(): asg = json.load(open(DATA / "_host_assignment.json", encoding="utf-8")) c3 = [json.loads(l) for l in open(DATA / "c3_trajectories.jsonl", encoding="utf-8") if l.strip()] byid = {r["example_id"]: r for r in c3} cat_orders = ["#" + o.lstrip("#").upper() for o in CATALOG.get("order_balances", {})] cat_cards = list(CATALOG.get("gift_card_balances", {})) injected, prov = [], [] fails, merged = [], [] seq = 0 for a in asg: host = byid[a["host"]] u = host_customer(host, a) oids = order_ids_for(a, u) cat_order = a.get("grounded_cat_order") or RND.choice(cat_orders) gift_card = a.get("grounded_card") or RND.choice(cat_cards) prefix_tools = a["prefix"] leaf = a["leaf"] calls, primary = G.assemble(prefix_tools, leaf, u, oids, cat_order, gift_card) calls, reconciled = reconcile_leaf_with_host(calls, host) miss = G.verify_row(calls) if miss: fails.append((a["host"], leaf, miss)) continue hist = embed_host_turn(host) n_user = sum(1 for m in hist if m["role"] == "user") turn_index = n_user + 1 total_turns = turn_index + RND.randint(1, 3) position_norm = round(turn_index / max(total_turns, 1), 4) tier = ("early" if position_norm < 0.34 else "middle" if position_norm < 0.67 else "late") shown = cat_order if leaf in ("reorder_previous_order", "apply_gift_card") else primary query = hq_variant(leaf, shown) eid = f"confuser-{leaf}-minj{seq:03d}" seq += 1 row = { "example_id": eid, "query": query, "retrieval_text": query, "calls": calls, "history": hist, "available_apis": None, "domain": "retail", "metadata": { "source": "synthetic", "distractor_class": "confuser", "model": "authored", "confuser": leaf, "twin": False, "twin_of": None, "anchor_state": list(prefix_tools), "anchor_depth": len(prefix_tools), "hotspot": False, "synthetic_query": True, "tier": tier, "turn_index": turn_index, "total_turns": total_turns, "position_norm": position_norm, "embed_history": True, "history": hist, "real_source": "authored-synthetic", }, } injected.append(row) prov.append({"example_id": eid, "rebalance_node": a["node"], "confuser": leaf, "host_of": a["host"], "uid": a["uid"], "placement": "later-turn", "reconciled_leaf": reconciled}) merged.append((eid, host["calls"] + calls, history_tool_calls(host))) (OUT / "_staging_merged_injections.jsonl").write_text( "\n".join(json.dumps(r) for r in injected) + "\n", encoding="utf-8") (OUT / "_merged_injections.prov.json").write_text(json.dumps(prov, indent=2), encoding="utf-8") print(f"assembled {len(injected)}/51 injected rows (replay-verified)") if fails: print(f"ASSEMBLY/REPLAY FAILURES: {len(fails)}") for f in fails[:20]: print(" ", f) tally = Counter((p["rebalance_node"], p["confuser"]) for p in prov) for k in sorted(tally): print(" ", k, tally[k]) print(" reconciled leaves (inherited host value):", sum(1 for p in prov if p.get("reconciled_leaf"))) # ---- PASS 1: find unmarked variables across every merged conversation ---- made_up = {} for eid, seq, hist in merged: fwd, _ = conversation_state_check(seq, CATALOG, hist) for (_i, tool, kind, val) in fwd: if kind == "order_id": oid = "#" + str(val).lstrip("#").upper() if oid not in CATALOG["order_balances"]: # mark the host-intrinsic order in the CLONED free-running DB. made_up[oid] = {"order_balances": 0.01, "reason": f"{eid}:{tool} unread order"} if made_up: for oid, rec in made_up.items(): CATALOG.setdefault("order_balances", {})[oid.lstrip("#")] = rec["order_balances"] (DATA / "catalog.json").write_text(json.dumps(CATALOG, indent=1), encoding="utf-8") (OUT / "_made_up_values.json").write_text(json.dumps(made_up, indent=2), encoding="utf-8") # ---- PASS 2: confirm the conversation is now fully marked + reproduces ---- fwd_all, io_all = [], [] for eid, seq, hist in merged: fwd, io = conversation_state_check(seq, CATALOG, hist) for f in fwd: fwd_all.append((eid,) + f) for m in io: io_all.append((eid,) + (m if isinstance(m, tuple) else (m,))) print(f"\nadded {len(made_up)} made-up var(s) to the cloned free-running DB") print(f"CONVERSATION STATE CHECK (final): forward/unmarked refs = {len(fwd_all)} ; " f"io mismatches = {len(io_all)}") for x in fwd_all[:20]: print(" FWD", x) for x in io_all[:20]: print(" IO ", x) ok = not fails and not fwd_all and not io_all print("\nRESULT:", "CLEAN" if ok else "NEEDS ATTENTION") return 0 if ok else 1 if __name__ == "__main__": raise SystemExit(main())