File size: 21,096 Bytes
fb6c876
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
eabbe1a
fb6c876
 
 
 
 
 
 
eabbe1a
 
 
 
fb6c876
 
 
 
 
 
 
 
 
 
 
 
eabbe1a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
fb6c876
 
 
eabbe1a
fb6c876
 
 
 
 
 
 
 
 
 
eabbe1a
 
fb6c876
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""OPUS-synth-tools: verified tool-use (function-calling) conversations in English and Turkish.

Every tool result in these conversations is the real return value of the reference
implementation in `opusdb.agent_tools`, executed while the example is generated, and every
final answer is derived from those results. The families teach a model *when* and *how*
to use tools, not only how to format a call:

    calc_single     hard arithmetic -> one calculator call
    calc_chain      two dependent calculator calls (result of the first feeds the second)
    parallel        two independent calls in the same assistant turn
    dates           date_calc for differences, offsets and weekdays
    python_compute  write a short program, run it, report the printed result
    python_repair   the first program fails, the model reads the error, fixes the code, re-runs
    tool_error      the tool returns an error (e.g. division by zero); the model explains it
    no_tool         the question is trivial -> answer directly without calling a tool
    out_of_scope    no available tool can do the task -> say so instead of inventing a call

Message format (OpenAI / Hugging Face chat-template compatible):
    {"role": "assistant", "content": "", "tool_calls": [{"id", "type": "function",
                                                         "function": {"name", "arguments": {...}}}]}
    {"role": "tool", "tool_call_id": "...", "name": "...", "content": "<json result>"}
"""
import datetime as dt
import json
import random
import statistics

from .agent_tools import TOOL_SPECS, call_tool
from .synth import NAMES_EN, NAMES_TR, WEEKDAYS, dstr
from .text import stable_id

SPEC = {t["function"]["name"]: t for t in TOOL_SPECS}
WEEKDAY_TR = dict(zip(WEEKDAYS["en"], WEEKDAYS["tr"]))


class Conv:
    def __init__(self, lang, user):
        self.lang = lang
        self.messages = [{"role": "user", "content": user}]
        self.n = 0

    def call(self, *calls, preface=""):
        """Assistant turn with one or more tool calls; executes them and appends tool messages."""
        tcs, results = [], []
        for name, args in calls:
            self.n += 1
            cid = f"call_{self.n}"
            tcs.append({"id": cid, "type": "function", "function": {"name": name, "arguments": args}})
            results.append((cid, name, call_tool(name, args)))
        self.messages.append({"role": "assistant", "content": preface, "tool_calls": tcs})
        for cid, name, res in results:
            self.messages.append({"role": "tool", "tool_call_id": cid, "name": name,
                                  "content": json.dumps(res, ensure_ascii=False)})
        return [r for _, _, r in results]

    def say(self, text):
        self.messages.append({"role": "assistant", "content": text})


def L(lang, en, tr):
    return en if lang == "en" else tr


def num(s):
    return s.replace(".", ",") if False else s


# ------------------------------------------------------------------ families
def calc_single(r, lang):
    kind = r.choice(["mul", "pow", "sqrt", "pct", "div"])
    if kind == "mul":
        a, b = r.randint(1000, 99999), r.randint(100, 9999)
        expr = f"{a} * {b}"
        q = L(lang, f"What is {a:,} × {b:,}?", f"{a} × {b} kaçtır?")
    elif kind == "pow":
        p, rate, n = r.choice([1000, 2500, 5000, 12000]), r.choice([3, 4.5, 6, 7.25, 9]), r.randint(3, 15)
        expr = f"{p} * (1 + {rate}/100)**{n}"
        q = L(lang, f"If I invest ${p} at {rate}% annual interest compounded yearly, how much will I have after {n} years?",
              f"{p} TL'yi yıllık %{rate} bileşik faizle yatırırsam {n} yıl sonra ne kadar param olur?")
    elif kind == "sqrt":
        a = r.randint(2, 99999)
        expr = f"sqrt({a})"
        q = L(lang, f"What is the square root of {a}, to 4 decimal places?", f"{a} sayısının karekökü nedir (4 ondalık basamak)?")
    elif kind == "pct":
        a, pc = r.randint(200, 900000), r.choice([2.5, 7, 12.5, 18, 23, 37.5])
        expr = f"{a} * {pc} / 100"
        q = L(lang, f"What is {pc}% of {a:,}?", f"{a} sayısının %{pc}'i kaçtır?")
    else:
        a, b = r.randint(10000, 9999999), r.randint(7, 997)
        expr = f"{a} / {b}"
        q = L(lang, f"Divide {a:,} by {b} and give the result to 3 decimal places.",
              f"{a} sayısını {b} sayısına bölün; sonucu 3 ondalık basamakla verin.")
    c = Conv(lang, q)
    res = c.call(("calculator", {"expression": expr}))[0]["result"]
    val = float(res)
    if kind == "sqrt":
        shown = f"{val:.4f}"
    elif kind == "div":
        shown = f"{val:.3f}"
    elif kind == "pow":
        shown = f"{val:,.2f}" if lang == "en" else f"{val:.2f}"
    else:
        shown = res
    if kind == "pow":
        c.say(L(lang, f"After {expr.split('**')[1]} years you would have about **${shown}** "
                      f"({expr.replace('**', '^')} = {res}).",
                f"{expr.split('**')[1]} yıl sonra yaklaşık **{shown} TL** olur ({expr.replace('**', '^')} = {res})."))
    else:
        c.say(L(lang, f"The result is **{shown}**.", f"Sonuç **{shown}**."))
    return "calc_single", c, shown


def calc_chain(r, lang):
    n = r.choice(NAMES_EN if lang == "en" else NAMES_TR)
    qty, price, disc, tax = r.randint(3, 40), round(r.uniform(4, 250), 2), r.choice([5, 10, 15, 20, 30]), r.choice([8, 10, 18, 20])
    q = L(lang, f"{n} orders {qty} items at ${price} each. There is a {disc}% discount on the order, and then {tax}% tax "
                f"is added. Use the calculator to find the final amount.",
          f"{n}, tanesi {price} TL olan {qty} ürün sipariş ediyor. Siparişe %{disc} indirim uygulanıyor, ardından %{tax} "
          f"vergi ekleniyor. Hesap makinesini kullanarak son tutarı bulun.")
    c = Conv(lang, q)
    sub = c.call(("calculator", {"expression": f"{qty} * {price} * (1 - {disc}/100)"}),
                 preface=L(lang, "First, the discounted subtotal.", "Önce indirimli ara toplamı hesaplayalım."))[0]["result"]
    tot = c.call(("calculator", {"expression": f"{sub} * (1 + {tax}/100)"}),
                 preface=L(lang, f"The discounted subtotal is {sub}. Now I add the {tax}% tax.",
                           f"İndirimli ara toplam {sub}. Şimdi %{tax} vergiyi ekliyorum."))[0]["result"]
    final = f"{float(tot):.2f}"
    c.say(L(lang, f"- Discounted subtotal: {qty} × ${price} × {1 - disc / 100:g} = ${float(sub):.2f}\n"
                  f"- With {tax}% tax: ${float(sub):.2f} × {1 + tax / 100:g} = **${final}**",
            f"- İndirimli ara toplam: {qty} × {price} × {1 - disc / 100:g} = {float(sub):.2f} TL\n"
            f"- %{tax} vergiyle: {float(sub):.2f} × {1 + tax / 100:g} = **{final} TL**"))
    return "calc_chain", c, final


def parallel(r, lang):
    convs = [(r.randint(1, 500), "km", "mi"), (r.randint(1, 300), "kg", "lb"), (r.randint(-40, 220), "F", "C"),
             (r.randint(1, 100), "gal", "l"), (r.randint(1, 1000), "ft", "m"), (r.randint(1, 72), "h", "min")]
    (v1, f1, t1), (v2, f2, t2) = r.sample(convs, 2)
    q = L(lang, f"Convert {v1} {f1} to {t1}, and also {v2} {f2} to {t2}.",
          f"{v1} {f1} kaç {t1} eder? Ayrıca {v2} {f2} kaç {t2} eder?")
    c = Conv(lang, q)
    a, b = c.call(("unit_convert", {"value": v1, "from_unit": f1, "to_unit": t1}),
                  ("unit_convert", {"value": v2, "from_unit": f2, "to_unit": t2}))
    ra, rb = f"{a['result']:.4g}", f"{b['result']:.4g}"
    c.say(L(lang, f"- {v1} {f1} = **{ra} {t1}**\n- {v2} {f2} = **{rb} {t2}**",
            f"- {v1} {f1} = **{ra} {t1}**\n- {v2} {f2} = **{rb} {t2}**"))
    return "parallel", c, f"{ra}; {rb}"


def dates(r, lang):
    d = dt.date(r.randint(2000, 2035), r.randint(1, 12), r.randint(1, 28))
    op = r.choice(["diff", "add_days", "weekday"])
    if op == "diff":
        d2 = d + dt.timedelta(days=r.randint(1, 2000))
        q = L(lang, f"How many days are there between {dstr(d, 'en')} and {dstr(d2, 'en')}?",
              f"{dstr(d, 'tr')} ile {dstr(d2, 'tr')} arasında kaç gün var?")
        c = Conv(lang, q)
        res = c.call(("date_calc", {"operation": "diff", "date": d.isoformat(), "other_date": d2.isoformat()}))[0]["result"]
        c.say(L(lang, f"There are **{res} days** between those dates.", f"Bu iki tarih arasında **{res} gün** var."))
        return "dates", c, str(res)
    if op == "add_days":
        k = r.randint(1, 1000)
        q = L(lang, f"What date is {k} days after {dstr(d, 'en')}?", f"{dstr(d, 'tr')} tarihinden {k} gün sonrası hangi tarihtir?")
        c = Conv(lang, q)
        res = c.call(("date_calc", {"operation": "add_days", "date": d.isoformat(), "days": k}))[0]["result"]
        out = dt.date.fromisoformat(res)
        c.say(L(lang, f"{k} days after {dstr(d, 'en')} is **{dstr(out, 'en')}**.",
                f"{dstr(d, 'tr')} tarihinden {k} gün sonrası **{dstr(out, 'tr')}** olur."))
        return "dates", c, res
    q = L(lang, f"What day of the week was {dstr(d, 'en')}?", f"{dstr(d, 'tr')} haftanın hangi günüydü?")
    c = Conv(lang, q)
    res = c.call(("date_calc", {"operation": "weekday", "date": d.isoformat()}))[0]["result"]
    c.say(L(lang, f"{dstr(d, 'en')} was a **{res}**.", f"{dstr(d, 'tr')} bir **{WEEKDAY_TR[res]}** günüydü."))
    return "dates", c, res


def python_compute(r, lang):
    kind = r.choice(["stats", "primes", "fib", "vowels", "collatz"])
    if kind == "stats":
        xs = [r.randint(1, 500) for _ in range(r.randint(8, 25))]
        q = L(lang, f"Here are some measurements: {xs}. What are the mean, median and sample standard deviation?",
              f"Ölçümler şunlar: {xs}. Ortalama, medyan ve örneklem standart sapması nedir?")
        code = (f"import statistics\nxs = {xs}\nprint(round(statistics.mean(xs), 3))\n"
                f"print(statistics.median(xs))\nprint(round(statistics.stdev(xs), 3))")
        c = Conv(lang, q)
        out = c.call(("python", {"code": code}))[0]["stdout"].split()
        assert float(out[0]) == round(statistics.mean(xs), 3)
        c.say(L(lang, f"- Mean: **{out[0]}**\n- Median: **{out[1]}**\n- Sample standard deviation: **{out[2]}**",
                f"- Ortalama: **{out[0]}**\n- Medyan: **{out[1]}**\n- Örneklem standart sapması: **{out[2]}**"))
        return "python_compute", c, " ".join(out)
    if kind == "primes":
        n = r.randint(1000, 200000)
        q = L(lang, f"How many prime numbers are there below {n:,}?", f"{n} sayısından küçük kaç asal sayı vardır?")
        code = (f"n = {n}\nsieve = bytearray([1]) * n\nsieve[0:2] = b'\\x00\\x00'\n"
                f"for i in range(2, int(n ** 0.5) + 1):\n    if sieve[i]:\n"
                f"        sieve[i*i::i] = bytearray(len(sieve[i*i::i]))\nprint(sum(sieve))")
        c = Conv(lang, q)
        out = c.call(("python", {"code": code}))[0]["stdout"].strip()
        c.say(L(lang, f"There are **{out}** primes below {n:,}.", f"{n} sayısından küçük **{out}** asal sayı vardır."))
        return "python_compute", c, out
    if kind == "fib":
        n = r.randint(50, 300)
        q = L(lang, f"What is the {n}th Fibonacci number (F(1) = F(2) = 1)?",
              f"{n}. Fibonacci sayısı nedir (F(1) = F(2) = 1)?")
        code = f"a, b = 1, 1\nfor _ in range({n} - 2):\n    a, b = b, a + b\nprint(b)"
        c = Conv(lang, q)
        out = c.call(("python", {"code": code}))[0]["stdout"].strip()
        c.say(L(lang, f"F({n}) = **{out}**", f"F({n}) = **{out}**"))
        return "python_compute", c, out
    if kind == "vowels":
        words = r.sample(["intelligence", "artificial", "language", "model", "training", "evaluation", "dataset",
                          "reasoning", "mathematics", "translation", "algorithm", "optimization"], 6)
        s = " ".join(words)
        q = L(lang, f"Count each vowel (a, e, i, o, u) in: \"{s}\"", f"Şu ifadedeki her ünlüyü (a, e, i, o, u) sayın: \"{s}\"")
        code = f"s = {s!r}\nfor v in 'aeiou':\n    print(v, s.count(v))"
        c = Conv(lang, q)
        out = c.call(("python", {"code": code}))[0]["stdout"].strip().splitlines()
        c.say("\n".join(f"- {line.split()[0]}: **{line.split()[1]}**" for line in out))
        return "python_compute", c, " ".join(out)
    n = r.randint(2, 10 ** 6)
    q = L(lang, f"How many steps does the Collatz sequence starting at {n} take to reach 1?",
          f"{n} ile başlayan Collatz dizisi 1'e kaç adımda ulaşır?")
    code = f"n, steps = {n}, 0\nwhile n != 1:\n    n = n // 2 if n % 2 == 0 else 3 * n + 1\n    steps += 1\nprint(steps)"
    c = Conv(lang, q)
    out = c.call(("python", {"code": code}))[0]["stdout"].strip()
    c.say(L(lang, f"Starting from {n}, it takes **{out} steps** to reach 1.", f"{n} sayısından başlayınca 1'e **{out} adımda** ulaşılır."))
    return "python_compute", c, out


def python_repair(r, lang):
    xs = [r.randint(1, 99) for _ in range(r.randint(6, 15))]
    bug = r.choice(["name", "type", "zero"])
    if bug == "name":
        bad = f"values = {xs}\ntotal = sum(value)\nprint(total / len(values))"
    elif bug == "type":
        bad = f"values = {xs}\nprint('Average: ' + sum(values) / len(values))"
    else:
        bad = f"values = {xs}\nevens = [v for v in values if v % 2 == 0 and v > 100]\nprint(sum(evens) / len(evens))"
    good = f"values = {xs}\nprint(round(sum(values) / len(values), 4))"
    q = L(lang, f"Use Python to compute the average of {xs}.", f"Python kullanarak {xs} listesinin ortalamasını hesaplayın.")
    c = Conv(lang, q)
    err = c.call(("python", {"code": bad}))[0]
    assert "error" in err, err
    fix = {"name": L(lang, "I used an undefined variable name (`value` instead of `values`). Fixing it.",
                     "Tanımlanmamış bir değişken adı kullandım (`values` yerine `value`). Düzeltiyorum."),
           "type": L(lang, "I tried to add a string and a number. I'll print the number directly.",
                     "Metin ile sayıyı toplamaya çalıştım. Sayıyı doğrudan yazdıracağım."),
           "zero": L(lang, "My filter removed every element, so I divided by zero. The task asks for the average of all values.",
                     "Filtrem tüm elemanları eledi ve sıfıra böldüm. Görev tüm değerlerin ortalamasını istiyor.")}[bug]
    out = c.call(("python", {"code": good}), preface=f"{err['error']} — {fix}")[0]["stdout"].strip()
    c.say(L(lang, f"The average is **{out}**.", f"Ortalama **{out}**."))
    return "python_repair", c, out


def tool_error(r, lang):
    a, b = r.randint(2, 999), r.randint(2, 50)
    expr = f"{a} / ({b} - {b})"
    q = L(lang, f"Calculate {a} / ({b} - {b}).", f"{a} / ({b} - {b}) işlemini hesaplayın.")
    c = Conv(lang, q)
    res = c.call(("calculator", {"expression": expr}))[0]
    assert res == {"error": "division by zero"}
    c.say(L(lang, f"This expression has no numerical value: the denominator is {b} - {b} = 0, and division by zero is "
                  f"undefined (the calculator reports \"division by zero\").",
            f"Bu ifadenin sayısal bir değeri yok: payda {b} - {b} = 0 ve sıfıra bölme tanımsızdır (hesap makinesi "
            f"\"division by zero\" hatası veriyor)."))
    return "tool_error", c, "UNDEFINED"


def no_tool(r, lang):
    a, b = r.randint(1, 20), r.randint(1, 20)
    op = r.choice(["+", "×", "-"])
    val = a + b if op == "+" else a * b if op == "×" else a - b
    if r.random() < 0.5:
        q = L(lang, f"Quick one: what is {a} {op} {b}?", f"Hızlı bir soru: {a} {op} {b} kaç?")
        c = Conv(lang, q)
        c.say(L(lang, f"{a} {op} {b} = **{val}**", f"{a} {op} {b} = **{val}**"))
        return "no_tool", c, str(val)
    who = r.choice(NAMES_EN if lang == "en" else NAMES_TR)
    q = r.choice([L(lang, f"Hi, I'm {who}! What kinds of things can you help me with using your tools?",
                    f"Merhaba, ben {who}! Araçlarınla bana hangi konularda yardım edebilirsin?"),
                  L(lang, f"Hello, this is {who}. Which tools do you have?", f"Selam, ben {who}. Hangi araçların var?")])
    c = Conv(lang, q)
    c.say(L(lang, "Hi! With the tools I have access to I can:\n- do exact arithmetic and math functions (calculator),\n"
                  "- run short Python programs for computations, statistics or data processing,\n"
                  "- do date arithmetic (days between dates, adding days, weekdays),\n"
                  "- convert units of length, mass, volume, time and temperature.\n\nWhat would you like to work on?",
            "Merhaba! Erişebildiğim araçlarla şunları yapabilirim:\n- tam aritmetik ve matematik fonksiyonları (hesap makinesi),\n"
            "- hesaplama, istatistik veya veri işleme için kısa Python programları çalıştırmak,\n"
            "- tarih hesapları (iki tarih arası gün, gün ekleme, haftanın günü),\n"
            "- uzunluk, kütle, hacim, zaman ve sıcaklık birimlerini dönüştürmek.\n\nNe üzerinde çalışmak istersiniz?"))
    return "no_tool", c, "DIRECT"


CITIES = ["Istanbul", "Ankara", "Izmir", "Berlin", "Paris", "London", "Madrid", "Rome", "Tokyo", "New York", "Dubai", "Vienna"]
DAYS_EN = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]


def _oos_request(r, lang):
    c1, c2 = r.sample(CITIES, 2)
    day = r.randrange(7)
    who = r.choice(NAMES_EN if lang == "en" else NAMES_TR)
    hh, mm = r.randint(6, 22), r.choice([0, 15, 30, 45])
    cur = r.choice([("USD", "EUR"), ("EUR", "TRY"), ("GBP", "USD"), ("USD", "TRY"), ("JPY", "EUR")])
    item = r.choice([("a large pizza", "büyük boy bir pizza"), ("two coffees", "iki kahve"), ("a taxi", "bir taksi"),
                     ("groceries for the week", "haftalık market alışverişi")])
    options = [
        (f"Book me a flight from {c1} to {c2} for {DAYS_EN[day]}.",
         f"{WEEKDAYS['tr'][day]} günü için {c1} - {c2} uçak bileti al.", "book flights"),
        (f"Send an email to {who} saying the meeting moved to {hh:02d}:{mm:02d}.",
         f"{who} adlı kişiye toplantının {hh:02d}:{mm:02d}'e alındığını söyleyen bir e-posta gönder.", "send e-mails"),
        (f"What's the weather like in {c1} right now?", f"Şu anda {c1} şehrinde hava nasıl?", "look up live weather"),
        (f"Order {item[0]} to my home.", f"Evime {item[1]} sipariş et.", "place orders"),
        (f"What is the current {cur[0]} to {cur[1]} exchange rate?", f"Şu anki {cur[0]}/{cur[1]} kuru nedir?",
         "fetch live exchange rates"),
        (f"Set an alarm for {hh:02d}:{mm:02d} tomorrow.", f"Yarın {hh:02d}:{mm:02d} için alarm kur.", "set alarms"),
        (f"Call {who} and tell them I'm on my way.", f"{who} adlı kişiyi ara ve yolda olduğumu söyle.", "make phone calls"),
        (f"Search the web for the latest news about {c1}.", f"{c1} hakkındaki son haberleri internette ara.",
         "browse the web"),
        (f"Check my bank balance.", f"Banka bakiyemi kontrol et.", "access bank accounts"),
    ]
    en, tr, ability = r.choice(options)
    return en, tr, ability


def out_of_scope(r, lang):
    en, tr, ability = _oos_request(r, lang)
    c = Conv(lang, L(lang, en, tr))
    c.say(L(lang, f"I can't do that: none of my available tools can {ability} (I only have a calculator, a Python "
                  f"runner, date arithmetic and unit conversion), and I don't have access to live or personal data. "
                  f"If you share the relevant details, I'm happy to help with any calculations or with drafting text.",
            f"Bunu yapamıyorum: elimdeki araçların hiçbiri bu işi yapamıyor (yalnızca hesap makinesi, Python çalıştırıcı, "
            f"tarih hesabı ve birim dönüştürme var) ve canlı ya da kişisel verilere erişimim yok. Gerekli bilgileri "
            f"paylaşırsanız hesaplamalarda veya metin hazırlamada memnuniyetle yardımcı olurum."))
    return "out_of_scope", c, "REFUSE"


FAMILIES = [(calc_single, 0.19), (calc_chain, 0.12), (parallel, 0.10), (dates, 0.12), (python_compute, 0.17),
            (python_repair, 0.08), (tool_error, 0.05), (no_tool, 0.08), (out_of_scope, 0.09)]


def generate(n, seed=0, tr_ratio=0.35):
    r = random.Random(seed)
    fns, ws = zip(*FAMILIES)
    seen = set()
    made = attempts = 0
    while made < n and attempts < n * 10:
        attempts += 1
        lang = "tr" if r.random() < tr_ratio else "en"
        fam, conv, answer = r.choices(fns, ws)[0](r, lang)
        prompt = conv.messages[0]["content"]
        if prompt in seen:
            continue
        seen.add(prompt)
        used = {tc["function"]["name"] for m in conv.messages for tc in m.get("tool_calls", [])}
        # expose all tools most of the time, sometimes only the needed ones plus distractors
        names = list(SPEC)
        if r.random() < 0.3 and used:
            names = sorted(used | set(r.sample(names, r.randint(0, 2))))
        made += 1
        yield {"id": "tools-" + stable_id(fam, lang, prompt), "family": fam, "language": lang,
               "messages": conv.messages, "tools": [SPEC[k] for k in names], "answer": answer}