Upload 13 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

chat_template.jinja

@@ -0,0 +1,89 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {%- if loop.last or (not loop.last and reasoning_content) %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+            {%- else %}
+                {{- '<|im_start|>' + message.role + '\n' + content }}
+            {%- endif %}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

claude-code/build_from_raw.py

@@ -0,0 +1,214 @@
+"""Build TinyGuide dataset from RAW Claude Code transcripts (not skeletons).
+
+Raw transcripts keep full tool inputs AND results — tracebacks, grep output,
+test pass/fail, error text — which the skeleton dropped. That lets every rule
+fire with real signal. One {prompt, completion} row per tool call.
+
+Usage:
+  python build_from_raw.py [glob ...]
+  (default sources: ~/.claude/projects/**/*.jsonl and /tmp/cc*/**/*.jsonl)
+"""
+import json, re, sys, glob, os, collections, random
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from label_rules import choose_label, HINTS
+from format_prompt import format_prompt
+
+random.seed(0)
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "data"
+
+TEST_RE = re.compile(r"\b(pytest|npm test|pnpm test|yarn test|cargo test|go test|bun test|unittest|jest|vitest|tox)\b")
+PY_TB_RE = re.compile(r'File "([^"]+\.\w+)", line \d+')
+PYTEST_PATH_RE = re.compile(r"\b([\w./-]+\.\w+):\d+\b")
+TEST_FAIL_RE = re.compile(r"\b(FAILED|failed|AssertionError|Error|Traceback|\d+ failed|exit code [1-9])", re.I)
+TEST_PASS_RE = re.compile(r"\b(\d+ passed|all tests passed|PASSED|\bOK\b|0 failed)\b")
+ENV_RE = re.compile(r"command not found|ModuleNotFoundError|No module named|is not recognized|ENOENT|cannot find module|: not found", re.I)
+NOTREAD_RE = re.compile(r"not been read yet|Read it first", re.I)
+SYMBOL_RE = re.compile(r"(?:NameError|AttributeError|ImportError|cannot import name).*?['\"`](\w+)['\"`]")
+
+
+def result_text(content):
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return " ".join(x.get("text", "") for x in content if isinstance(x, dict))
+    return str(content or "")
+
+
+def iter_pairs(path):
+    """Yield (tool_name, input_dict, result_text, is_error) in order."""
+    pending = {}
+    try:
+        rows = [json.loads(l) for l in open(path) if l.strip()]
+    except Exception:
+        return
+    goal = ""
+    for r in rows:
+        msg = r.get("message", {}) or {}
+        content = msg.get("content")
+        if r.get("type") == "user" and isinstance(content, str) and not goal:
+            goal = content.strip()
+        if not isinstance(content, list):
+            continue
+        for c in content:
+            if not isinstance(c, dict):
+                continue
+            if c.get("type") == "text" and not goal and r.get("type") == "user":
+                goal = c.get("text", "").strip()
+            if c.get("type") == "tool_use":
+                pending[c.get("id")] = (c.get("name"), c.get("input", {}) or {})
+            if c.get("type") == "tool_result":
+                tid = c.get("tool_use_id")
+                if tid in pending:
+                    name, inp = pending.pop(tid)
+                    yield goal, name, inp, result_text(c.get("content")), bool(c.get("is_error"))
+
+
+def first_path(text):
+    m = PY_TB_RE.search(text) or PYTEST_PATH_RE.search(text)
+    return m.group(1) if m else None
+
+
+def session_rows(path):
+    state = {
+        "observed_files": [], "edited_files": [], "traceback_paths": [],
+        "command_history": [], "last_test_status": "unknown",
+        "code_changed_since_last_test": False, "traceback_symbols": [],
+        "last_failure_type": None, "last_error_signature": None,
+        "previous_error_signature": None, "last_search_result_class": None,
+        "last_test_failed_same_error_after_edit": False,
+    }
+    traj, rows, goal_final = [], [], "Continue the task."
+    for goal, name, inp, res, is_err in iter_pairs(path):
+        goal_final = goal or goal_final
+        prop = {"name": name, "args": inp}
+        # NOTE: no back-to-back cooldown here. Cooldown is a RUNTIME hook
+        # concern; baking it into labels gives identical signal patterns two
+        # different labels (VERIFY vs NO_HINT) -> ambiguous supervision ->
+        # model collapses to NO_HINT on real prompts. Label the true rule.
+        key = choose_label(state, prop)
+        prompt = format_prompt(goal_final, traj, state, prop)
+        rows.append({"key": key, "prompt": prompt, "completion": HINTS[key]})
+        _advance(state, traj, name, inp, res, is_err)
+    return rows
+
+
+def _advance(state, traj, name, inp, res, is_err):
+    fp = inp.get("file_path")
+    cmd = inp.get("command", "") or inp.get("pattern", "")
+    short = (fp or cmd or json.dumps(inp))[:60]
+    traj.append({"tool": name, "arg": short,
+                 "result": ("ERR " + res[:70]) if is_err else (res[:70] or "ok")})
+    if len(traj) > 14:
+        del traj[0]
+
+    if name == "Read" and fp and not is_err:
+        state["observed_files"].append(fp)
+    if name in {"Edit", "Write", "MultiEdit", "NotebookEdit"} and fp:
+        if NOTREAD_RE.search(res):
+            return  # failed edit; nothing changed, state already triggered the hint
+        state["edited_files"].append(fp)
+        if fp not in state["observed_files"]:
+            state["observed_files"].append(fp)
+        state["code_changed_since_last_test"] = True
+    if name in {"Grep", "Glob"}:
+        n = len(re.findall(r"\n", res))
+        state["last_search_result_class"] = ("search_no_results" if not res.strip()
+                                             else "search_many_results" if n > 30 else "search_few")
+    if name == "Bash":
+        state["command_history"].append(cmd)
+        sig = (res.strip().splitlines() or [""])[-1][:80]
+        # failure type reflects only THIS command's result (not sticky)
+        state["last_failure_type"] = "missing_package" if ENV_RE.search(res) else None
+        if TEST_RE.search(cmd):
+            if TEST_FAIL_RE.search(res) and not TEST_PASS_RE.search(res):
+                state["last_test_status"] = "failed"
+                tb = first_path(res)
+                if tb:
+                    state["traceback_paths"].append(tb)
+                sym = SYMBOL_RE.search(res)
+                if sym:
+                    state["traceback_symbols"].append(sym.group(1))
+                state["last_test_failed_same_error_after_edit"] = (sig == state.get("last_error_signature"))
+            else:
+                state["last_test_status"] = "passed"
+                state["last_failure_type"] = None
+            state["code_changed_since_last_test"] = False
+        if is_err or TEST_FAIL_RE.search(res):
+            state["previous_error_signature"] = state.get("last_error_signature")
+            state["last_error_signature"] = sig
+
+
+def main():
+    pats = sys.argv[1:] or [
+        os.path.expanduser("~/.claude/projects/**/*.jsonl"),
+        "/tmp/cc*/**/*.jsonl", "/tmp/cc*/*.jsonl",
+        "/tmp/mimo/**/*.jsonl",
+    ]
+    files = sorted({f for p in pats for f in glob.glob(p, recursive=True)})
+    print(f"transcripts found: {len(files)}")
+
+    sessions = []
+    for f in files:
+        rs = session_rows(f)
+        if rs:
+            sessions.append((Path(f).stem, rs))
+    print(f"sessions with tool calls: {len(sessions)}")
+
+    random.shuffle(sessions)
+    split = int(len(sessions) * 0.9)
+
+    def emit(sess, path, balance):
+        allrows = [r for _sid, rs in sess for r in rs]
+        # drop consecutive duplicate hints within nothing -> dedup globally per session done below
+        hints = [r for r in allrows if r["key"] != "NO_HINT"]
+        nohint = [r for r in allrows if r["key"] == "NO_HINT"]
+        random.shuffle(hints); random.shuffle(nohint)
+        if balance and hints:
+            # cap any single hint class to 35% of hints to avoid one rule dominating
+            cap = max(50, int(len(hints) * 0.35))
+            seen = collections.Counter(); kept = []
+            for r in hints:
+                if seen[r["key"]] < cap:
+                    kept.append(r); seen[r["key"]] += 1
+            hints = kept
+            # target ~75% NO_HINT
+            keep_no = min(len(nohint), int(len(hints) / 0.25 * 0.75))
+            nohint = nohint[:keep_no]
+        out = hints + nohint
+        random.shuffle(out)
+        with open(path, "w") as fh:
+            for r in out:
+                fh.write(json.dumps({"prompt": r["prompt"], "completion": r["completion"]}) + "\n")
+        return out
+
+    OUT.mkdir(exist_ok=True)
+    tr = emit(sessions[:split], OUT / "train.jsonl", balance=True)
+    va = emit(sessions[split:], OUT / "valid.jsonl", balance=True)
+
+    # dump ALL rows (unbalanced, with key), session-split preserved, for build_scaled.py
+    def dump_all(sess, path):
+        with open(path, "w") as fh:
+            for sid, rs in sess:
+                for r in rs:
+                    fh.write(json.dumps({"key": r["key"], "prompt": r["prompt"],
+                                         "completion": r["completion"],
+                                         "source": "real", "session_id": sid}) + "\n")
+    dump_all(sessions[:split], OUT / "all_train.jsonl")
+    dump_all(sessions[split:], OUT / "all_valid.jsonl")
+
+    def dist(rows):
+        c = collections.Counter("NO_HINT" if r["completion"] == "NO_HINT" else "HINT" for r in rows)
+        return dict(c)
+    print(f"train rows: {len(tr)} {dist(tr)}")
+    print(f"valid rows: {len(va)} {dist(va)}")
+    spread = collections.Counter(r["completion"][:34] for _sid, rs in sessions for r in rs)
+    print("label spread (all sessions, pre-balance):")
+    for k, n in spread.most_common():
+        print(f"  {n:6d}  {k}")
+
+
+if __name__ == "__main__":
+    main()

claude-code/clean_output.py

@@ -0,0 +1,52 @@
+"""Strict filter on model output. Returns hint str or None."""
+
+KNOWN_HINTS = [
+    "Read the traceback file before editing.",
+    "Read the file before editing it.",
+    "Run the focused failing test now.",
+    "Do not patch the same hypothesis again.",
+    "Search the exact symbol from the error.",
+    "Change strategy; this command already failed.",
+    "Check the project's package manager first.",
+    "Use the latest error, not the original one.",
+    "Verify the change before finalizing.",
+]
+
+BANNED = ["<think>", "</think>", "because", "step 1", "first,", "second,", "plan:", "i think"]
+
+
+import re
+_THINK = re.compile(r"<think>.*?</think>", re.S)
+
+
+def clean_hint(text):
+    text = _THINK.sub("", text).strip()  # drop empty think block
+    text = text.splitlines()[0].strip() if text.strip() else ""
+    if text == "NO_HINT":
+        return None
+    if any(x in text.lower() for x in BANNED):
+        return None
+    if len(text.split()) > 12:
+        return None
+    marks = text.count(".") + text.count("!") + text.count("?")
+    if marks > 1:
+        return None
+    if marks == 0:
+        text += "."
+    if text not in KNOWN_HINTS:
+        return None
+    return text
+
+
+def demo():
+    assert clean_hint("NO_HINT") is None
+    assert clean_hint("Read the file before editing it.") == "Read the file before editing it."
+    assert clean_hint("Read the file before editing it") == "Read the file before editing it."  # adds period
+    assert clean_hint("First, I think we should because reasons.") is None  # banned + not known
+    assert clean_hint("blah blah not a known hint at all here.") is None
+    assert clean_hint("This is a very long sentence with way more than twelve words in it indeed yes.") is None
+    print("clean_output ok")
+
+
+if __name__ == "__main__":
+    demo()

claude-code/format_prompt.py

@@ -0,0 +1,100 @@
+"""Build the PreToolUse prompt from session state + proposed action.
+
+The <signals> block surfaces the actual decision features as explicit
+booleans so the model latches onto them instead of re-deriving from raw
+state. Both the synthetic and real builders call format_prompt, so train
+and inference prompts stay identical.
+"""
+import re
+
+TEST_RE = re.compile(r"\b(pytest|npm test|pnpm test|yarn test|cargo test|go test|bun test|unittest|jest|vitest|tox)\b")
+
+TEMPLATE = """<task>
+{goal}
+</task>
+
+<recent_trajectory>
+{trajectory}
+</recent_trajectory>
+
+<state>
+observed_files: {observed_files}
+edited_files: {edited_files}
+traceback_path: {traceback_path}
+traceback_symbols: {traceback_symbols}
+last_test_status: {last_test_status}
+last_search_result_class: {last_search_result_class}
+code_changed_since_last_test: {code_changed_since_last_test}
+</state>
+
+<proposed_action>
+Tool: {tool}
+Args: {args}
+</proposed_action>
+
+<signals>
+proposed_edit_path: {proposed_edit_path}
+proposed_action_is_test: {proposed_action_is_test}
+traceback_file_read: {traceback_file_read}
+edit_target_read: {edit_target_read}
+last_failure_type: {last_failure_type}
+repeated_command: {repeated_command}
+</signals>
+
+<instruction>
+Output exactly one short sentence of guidance, or NO_HINT.
+</instruction>
+"""
+
+
+def _join(v, last=None):
+    if not v:
+        return "none"
+    if isinstance(v, (list, tuple)):
+        v = list(v)[-last:] if last else list(v)
+        return ", ".join(str(x) for x in v) if v else "none"
+    return str(v)
+
+
+def _b(x):
+    return str(bool(x)).lower()
+
+
+def format_prompt(goal, trajectory, state, proposed):
+    goal = goal.strip()
+    if len(goal) > 500:
+        goal = goal[:500] + " …"
+    tool = proposed["name"]
+    args = proposed.get("args", {}) or {}
+    cmd = args.get("command", "") or ""
+    edit_path = args.get("file_path") if tool in {"Edit", "Write", "MultiEdit", "NotebookEdit"} else None
+    observed = set(state.get("observed_files") or [])
+    tb = (state.get("traceback_paths") or [None])[-1]
+    hist = state.get("command_history") or []
+
+    return TEMPLATE.format(
+        goal=goal,
+        trajectory=trajectory.strip() if isinstance(trajectory, str) else _fmt_traj(trajectory),
+        observed_files=_join(state.get("observed_files"), last=20),
+        edited_files=_join(state.get("edited_files"), last=20),
+        traceback_path=tb or "none",
+        traceback_symbols=_join(state.get("traceback_symbols"), last=5),
+        last_test_status=state.get("last_test_status", "unknown"),
+        last_search_result_class=state.get("last_search_result_class") or "none",
+        code_changed_since_last_test=_b(state.get("code_changed_since_last_test")),
+        tool=tool,
+        args=_join(edit_path or cmd or args)[:200],
+        proposed_edit_path=edit_path or "none",
+        proposed_action_is_test=_b(tool == "Bash" and TEST_RE.search(cmd)),
+        traceback_file_read=_b(tb and tb in observed),
+        edit_target_read=_b(edit_path and edit_path in observed),
+        last_failure_type=state.get("last_failure_type") or "none",
+        repeated_command=_b(tool == "Bash" and cmd and sum(1 for x in hist[-3:] if x == cmd) >= 2),
+    )
+
+
+def _fmt_traj(calls):
+    lines = []
+    for i, c in enumerate(calls[-12:], 1):
+        lines.append(f"{i}. {c['tool']}: {c.get('arg','')}\n   Result: {c.get('result','')}")
+    return "\n".join(lines) if lines else "none"

claude-code/hook_pretooluse.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Claude Code PreToolUse hook -> TinyGuide hint (advisory, non-blocking).
+
+Reads the PreToolUse JSON on stdin, replays transcript_path to rebuild the
+agent state, asks the local mlx_lm.server for a hint, and surfaces it to
+Claude. Never blocks the tool: any error / no-hint -> silent exit 0.
+
+A tiny on-disk cooldown file enforces the runtime suppression that we
+deliberately kept OUT of the training labels.
+"""
+import json, sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+from build_from_raw import iter_pairs, _advance
+from format_prompt import format_prompt
+from infer import get_hint
+
+COOLDOWN = Path("/tmp/tinyguide_cooldown.json")
+MIN_CALLS_BETWEEN = 3 # >=3 tool calls between hints
+MAX_PER_SESSION = 5   # cap hints per session
+
+
+def base_state():
+    return {"observed_files": [], "edited_files": [], "traceback_paths": [],
+            "command_history": [], "last_test_status": "unknown",
+            "code_changed_since_last_test": False, "traceback_symbols": [],
+            "last_failure_type": None, "last_error_signature": None,
+            "previous_error_signature": None, "last_search_result_class": None,
+            "last_test_failed_same_error_after_edit": False}
+
+
+def rebuild(transcript_path):
+    """Replay completed tool calls -> (state, traj, goal, n_calls)."""
+    state, traj, goal, n = base_state(), [], "Continue the task.", 0
+    try:
+        for g, name, inp, res, is_err in iter_pairs(transcript_path):
+            goal = g or goal
+            _advance(state, traj, name, inp, res, is_err)
+            n += 1
+    except Exception:
+        pass
+    return state, traj, goal, n
+
+
+def cooldown_ok(session_id, n_calls):
+    """True if allowed to hint now; updates the cooldown file when it returns True."""
+    try:
+        data = json.loads(COOLDOWN.read_text()) if COOLDOWN.exists() else {}
+    except Exception:
+        data = {}
+    s = data.get(session_id, {"count": 0, "last_call": -999})
+    if s["count"] >= MAX_PER_SESSION:
+        return False, data, s
+    if n_calls - s["last_call"] < MIN_CALLS_BETWEEN:
+        return False, data, s
+    return True, data, s
+
+
+def main():
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        sys.exit(0)
+
+    tool = payload.get("tool_name")
+    inp = payload.get("tool_input", {}) or {}
+    transcript = payload.get("transcript_path", "")
+    session_id = payload.get("session_id", "default")
+    if not tool or not transcript:
+        sys.exit(0)
+
+    state, traj, goal, n_calls = rebuild(transcript)
+    proposed = {"name": tool, "args": inp}
+    prompt = format_prompt(goal, traj, state, proposed)
+
+    hint = get_hint(prompt)
+    if not hint:
+        sys.exit(0)
+
+    ok, data, s = cooldown_ok(session_id, n_calls)
+    if not ok:
+        sys.exit(0)
+    # record
+    data[session_id] = {"count": s["count"] + 1, "last_call": n_calls}
+    try:
+        COOLDOWN.write_text(json.dumps(data))
+    except Exception:
+        pass
+
+    # advisory context to Claude, non-blocking
+    print(json.dumps({
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "allow",
+            "additionalContext": f"TinyGuide hint: {hint}",
+        }
+    }))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

claude-code/infer.py

@@ -0,0 +1,29 @@
+"""Call the local mlx_lm.server for one hint. Returns hint str or None."""
+import json, urllib.request
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).parent))
+from clean_output import clean_hint
+
+URL = "http://127.0.0.1:8080/v1/chat/completions"
+
+
+def get_hint(prompt, timeout=8.0):
+    body = json.dumps({
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 24,
+        "temperature": 0.0,
+    }).encode()
+    req = urllib.request.Request(URL, data=body, headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            out = json.load(r)
+        text = out["choices"][0]["message"]["content"]
+    except Exception:
+        return None  # server down / timeout so no hint, never break the tool
+    return clean_hint(text) 
+
+
+if __name__ == "__main__":
+    print(get_hint(sys.stdin.read()))

claude-code/settings.snippet.json

@@ -0,0 +1,17 @@
+{
+  "//": "Merge this into ~/.claude/settings.json. Adjust PYTHON and HOOK paths.",
+  "//python": "Use the venv python that has mlx_lm + outlines installed.",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/ABS/PATH/.venv/bin/python /ABS/PATH/claude-code/hook_pretooluse.py"
+          }
+        ]
+      }
+    ]
+  }
+}

config.json

@@ -0,0 +1,33 @@
+{
+    "architectures": [
+        "Qwen3ForCausalLM"
+    ],
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "bos_token_id": 151643,
+    "eos_token_id": [
+        151645,
+        151643
+    ],
+    "head_dim": 128,
+    "hidden_act": "silu",
+    "hidden_size": 1024,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "max_position_embeddings": 40960,
+    "max_window_layers": 28,
+    "model_type": "qwen3",
+    "num_attention_heads": 16,
+    "num_hidden_layers": 28,
+    "num_key_value_heads": 8,
+    "rms_norm_eps": 1e-06,
+    "rope_scaling": null,
+    "rope_theta": 1000000,
+    "sliding_window": null,
+    "tie_word_embeddings": true,
+    "torch_dtype": "bfloat16",
+    "transformers_version": "4.51.0",
+    "use_cache": true,
+    "use_sliding_window": false,
+    "vocab_size": 151936
+}

generation_config.json

@@ -0,0 +1,13 @@
+{
+    "bos_token_id": 151643,
+    "do_sample": true,
+    "eos_token_id": [
+        151645,
+        151643
+    ],
+    "pad_token_id": 151643,
+    "temperature": 0.6,
+    "top_k": 20,
+    "top_p": 0.95,
+    "transformers_version": "4.51.0"
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d87519aa0367b990688f74acdcdedb3aca2d371a2ba830c533dda10c8d70b317
+size 1192134935

model.safetensors.index.json

@@ -0,0 +1,318 @@
+{
+    "metadata": {
+        "total_size": 1192099840,
+        "total_parameters": 596049920
+    },
+    "weight_map": {
+        "model.embed_tokens.weight": "model.safetensors",
+        "model.layers.0.input_layernorm.weight": "model.safetensors",
+        "model.layers.0.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.0.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.0.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.0.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.0.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.0.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.0.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.0.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.0.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.0.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.1.input_layernorm.weight": "model.safetensors",
+        "model.layers.1.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.1.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.1.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.1.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.1.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.1.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.1.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.1.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.1.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.1.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.10.input_layernorm.weight": "model.safetensors",
+        "model.layers.10.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.10.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.10.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.10.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.10.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.10.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.10.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.10.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.10.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.10.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.11.input_layernorm.weight": "model.safetensors",
+        "model.layers.11.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.11.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.11.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.11.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.11.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.11.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.11.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.11.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.11.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.11.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.12.input_layernorm.weight": "model.safetensors",
+        "model.layers.12.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.12.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.12.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.12.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.12.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.12.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.12.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.12.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.12.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.12.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.13.input_layernorm.weight": "model.safetensors",
+        "model.layers.13.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.13.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.13.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.13.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.13.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.13.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.13.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.13.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.13.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.13.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.14.input_layernorm.weight": "model.safetensors",
+        "model.layers.14.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.14.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.14.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.14.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.14.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.14.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.14.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.14.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.14.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.14.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.15.input_layernorm.weight": "model.safetensors",
+        "model.layers.15.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.15.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.15.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.15.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.15.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.15.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.15.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.15.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.15.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.15.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.16.input_layernorm.weight": "model.safetensors",
+        "model.layers.16.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.16.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.16.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.16.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.16.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.16.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.16.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.16.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.16.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.16.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.17.input_layernorm.weight": "model.safetensors",
+        "model.layers.17.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.17.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.17.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.17.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.17.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.17.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.17.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.17.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.17.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.17.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.18.input_layernorm.weight": "model.safetensors",
+        "model.layers.18.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.18.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.18.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.18.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.18.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.18.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.18.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.18.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.18.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.18.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.19.input_layernorm.weight": "model.safetensors",
+        "model.layers.19.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.19.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.19.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.19.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.19.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.19.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.19.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.19.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.19.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.19.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.2.input_layernorm.weight": "model.safetensors",
+        "model.layers.2.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.2.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.2.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.2.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.2.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.2.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.2.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.2.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.2.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.2.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.20.input_layernorm.weight": "model.safetensors",
+        "model.layers.20.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.20.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.20.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.20.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.20.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.20.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.20.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.20.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.20.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.20.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.21.input_layernorm.weight": "model.safetensors",
+        "model.layers.21.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.21.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.21.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.21.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.21.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.21.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.21.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.21.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.21.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.21.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.22.input_layernorm.weight": "model.safetensors",
+        "model.layers.22.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.22.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.22.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.22.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.22.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.22.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.22.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.22.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.22.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.22.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.23.input_layernorm.weight": "model.safetensors",
+        "model.layers.23.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.23.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.23.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.23.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.23.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.23.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.23.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.23.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.23.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.23.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.24.input_layernorm.weight": "model.safetensors",
+        "model.layers.24.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.24.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.24.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.24.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.24.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.24.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.24.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.24.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.24.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.24.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.25.input_layernorm.weight": "model.safetensors",
+        "model.layers.25.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.25.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.25.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.25.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.25.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.25.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.25.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.25.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.25.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.25.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.26.input_layernorm.weight": "model.safetensors",
+        "model.layers.26.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.26.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.26.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.26.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.26.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.26.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.26.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.26.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.26.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.26.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.27.input_layernorm.weight": "model.safetensors",
+        "model.layers.27.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.27.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.27.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.27.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.27.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.27.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.27.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.27.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.27.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.27.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.3.input_layernorm.weight": "model.safetensors",
+        "model.layers.3.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.3.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.3.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.3.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.3.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.3.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.3.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.3.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.3.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.3.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.4.input_layernorm.weight": "model.safetensors",
+        "model.layers.4.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.4.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.4.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.4.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.4.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.4.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.4.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.4.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.4.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.4.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.5.input_layernorm.weight": "model.safetensors",
+        "model.layers.5.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.5.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.5.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.5.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.5.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.5.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.5.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.5.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.5.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.5.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.6.input_layernorm.weight": "model.safetensors",
+        "model.layers.6.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.6.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.6.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.6.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.6.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.6.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.6.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.6.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.6.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.6.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.7.input_layernorm.weight": "model.safetensors",
+        "model.layers.7.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.7.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.7.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.7.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.7.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.7.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.7.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.7.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.7.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.7.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.8.input_layernorm.weight": "model.safetensors",
+        "model.layers.8.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.8.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.8.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.8.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.8.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.8.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.8.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.8.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.8.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.8.self_attn.v_proj.weight": "model.safetensors",
+        "model.layers.9.input_layernorm.weight": "model.safetensors",
+        "model.layers.9.mlp.down_proj.weight": "model.safetensors",
+        "model.layers.9.mlp.gate_proj.weight": "model.safetensors",
+        "model.layers.9.mlp.up_proj.weight": "model.safetensors",
+        "model.layers.9.post_attention_layernorm.weight": "model.safetensors",
+        "model.layers.9.self_attn.k_norm.weight": "model.safetensors",
+        "model.layers.9.self_attn.k_proj.weight": "model.safetensors",
+        "model.layers.9.self_attn.o_proj.weight": "model.safetensors",
+        "model.layers.9.self_attn.q_norm.weight": "model.safetensors",
+        "model.layers.9.self_attn.q_proj.weight": "model.safetensors",
+        "model.layers.9.self_attn.v_proj.weight": "model.safetensors",
+        "model.norm.weight": "model.safetensors"
+    }
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be75606093db2094d7cd20f3c2f385c212750648bd6ea4fb2bf507a6a4c55506
+size 11422650

tokenizer_config.json

@@ -0,0 +1,31 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "tool_parser_type": "json_tools",
+  "unk_token": null
+}