| """Прогон задач WorkPermit агентом DeepSeek Harness (dsh) в безголовом режиме. Для прогона нужен только датасет: кода |
| сравниваемых систем не нужно. |
| |
| Агент выполняет команды оболочки без подтверждения, поэтому работает только в контейнере (``Dockerfile`` рядом) во |
| внутренней сети Docker без выхода наружу. Модель он видит через шлюз (``gate.js``): контейнер, который пересылает запросы |
| на один адрес модели и оставляет в запросе одно, последнее изображение (сервер модели принимает одно за запрос). Рядом, |
| в той же сети, работают серверы MCP задачи (``desk/server.py``): подключённая система (двойник 1С, Jira или GitHub), |
| долговременная память и органайзер человека; агент подключает их плагином ``dsh-mcp-client``. |
| |
| Задача идёт так же, как у любой системы бенчмарка: |
| |
| * материалы ложатся в рабочую папку агента по местам человека: «Вложения» (приходят со своим сообщением), «База знаний |
| «…»», «Мои файлы»; к словам человека добавляется одна строка о том, где они и куда класть готовые файлы; |
| * сообщения одного разговора идут одной сессией агента (``--session-id``), другого разговора — новой; память между |
| разговорами — сервер памяти; |
| * на вопрос агента уходит ответ человека, не больше двух раз: заготовленный задачей (``reply_if_asked``), а после |
| последнего сообщения, если вопрос не верный исход задачи, общий «Других сведений у меня нет. Сделай по тому, что есть.»; |
| вопросом считается ответ, который кончается вопросительным знаком и не изменил ни одного документа в папке; |
| * выданное — новые документы рабочей папки и изменённые файлы человека; органайзер после задачи и выдача подключённой |
| системы снимаются с серверов MCP; всё пишется в ``record.json`` (формат описан в ``eval/checks.py``). |
| |
| python run.py <датасет> <папка прогонов> [--base-url http://модель:8000/v1] [--model <модель>] [--name <прогон>] |
| [--only <задача или номер>,…] [--again] |
| |
| Модель без ключей берётся из переменных окружения WORKPERMIT_MODEL_URL и WORKPERMIT_MODEL, общих с судьёй |
| (``eval/judge.py``, ``eval/evaluate.py``). Ключ модели — переменная WORKPERMIT_MODEL_KEY; он передаётся контейнеру |
| переменной и нигде не записывается. |
| Образ агента: ``docker build -t workpermit-dsh:0.2.0-rc.2 runners/dsh``. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import shutil |
| import subprocess |
| import sys |
| import time |
| import uuid |
| from datetime import datetime |
| from pathlib import Path |
| from urllib.parse import urlsplit |
|
|
| HERE = Path(__file__).resolve().parent |
| SYSTEM = "dsh" |
| IMAGE = "workpermit-dsh:0.2.0-rc.2" |
| KEY_ENV = "WORKPERMIT_MODEL_KEY" |
| NO_KEY = "none" |
| NETWORK = "workpermit-offline" |
| GATE = "workpermit-model-gate" |
| GATE_VERSION = "one-image-2" |
| DESK_PORT = 8080 |
| DEFAULT_REPLY = "Других сведений у меня нет. Сделай по тому, что есть." |
| DELIVERED = {".docx", ".xlsx", ".pdf", ".pptx", ".csv", ".md", ".txt"} |
| SYSTEMS = {"onec", "jira", "github"} |
| INVALID = set('"<>|:*?\\/') | {chr(c) for c in range(32)} |
|
|
|
|
| |
|
|
| def _files(dataset: Path, entries: list[dict]) -> list[dict]: |
| """Файлы материалов, сверенные по SHA-256 с датасетом: любая система получает байт в байт опубликованное.""" |
| result = [] |
| for entry in entries: |
| path = dataset / entry["path"] |
| sha = hashlib.sha256(path.read_bytes()).hexdigest() |
| if sha != entry["sha256"]: |
| raise RuntimeError(f"SHA-256 файла «{path}» не совпадает с датасетом: {sha} ≠ {entry['sha256']}") |
| result.append({"name": entry["name"], "path": path, "sha256": sha}) |
| return result |
|
|
|
|
| def load_tasks(dataset: Path) -> list[dict]: |
| corpora: dict[str, tuple] = {} |
| tasks = [] |
| for line in (dataset / "data" / "tasks.jsonl").read_text(encoding="utf-8").splitlines(): |
| if not line.strip(): |
| continue |
| task = json.loads(line) |
| bases, my_files = [], _files(dataset, task["my_files"]) |
| if task.get("corpus"): |
| key = task["corpus"]["id"] |
| if key not in corpora: |
| manifest = json.loads((dataset / "corpora" / key / "manifest.json").read_text(encoding="utf-8")) |
| corpora[key] = (manifest["title"], manifest["placement"], _files(dataset, manifest["files"])) |
| title, placement, files = corpora[key] |
| if placement == "knowledge_base": |
| bases.append((title, files)) |
| else: |
| my_files = files + my_files |
| bases += [(base["name"], _files(dataset, base["files"])) for base in task["knowledge_bases"]] |
| turns = [{"text": t["text"], "attachments": _files(dataset, t["attachments"]), "chat": t.get("chat") or "main"} for t in task["turns"]] |
| tasks.append({**task, "bases": bases, "my": my_files, "messages": turns, |
| "expects_question": any(c.get("kind") == "asked" for c in task.get("checks", []))}) |
| return tasks |
|
|
|
|
| def reply_after(task: dict, index: int) -> str | None: |
| """Ответ человека на вопрос после сообщения ``index``: заготовленный задачей — после любого сообщения; общий — только |
| после последнего и когда вопрос не верный исход задачи. После сообщения, за которым идёт следующее, человек не |
| отвечает на вопрос, а пишет дальше по сценарию.""" |
| if task.get("reply_if_asked"): |
| return task["reply_if_asked"] |
| return None if task["expects_question"] or index != len(task["messages"]) - 1 else DEFAULT_REPLY |
|
|
|
|
| def request(task: dict, turn: dict) -> str: |
| """Слова человека и строка о том, где лежат материалы и куда класть готовые файлы.""" |
| where = [] |
| if turn["attachments"]: |
| where.append("приложенные к этому сообщению файлы лежат в папке «Вложения»") |
| where += [f"документы базы знаний «{name}» лежат в папке «База знаний «{name}»»" for name, _ in task["bases"]] |
| if task["my"]: |
| where.append("файлы хранилища человека лежат в папке «Мои файлы»") |
| line = f"В рабочей папке: {'; '.join(where)}. " if where else "" |
| return f"{turn['text']}\n\n{line}Готовые файлы сохраняй в рабочую папку." |
|
|
|
|
| |
|
|
| def docker(*args: str, check: bool = False) -> subprocess.CompletedProcess: |
| done = subprocess.run(["docker", *args], capture_output=True, text=True, encoding="utf-8", errors="replace") |
| if check and done.returncode != 0: |
| raise RuntimeError(f"docker {' '.join(args[:2])}: {(done.stdout + done.stderr).strip()}") |
| return done |
|
|
|
|
| def model_gate(base_url: str, image: str) -> str: |
| """Адрес модели для агента: шлюз во внутренней сети, единственный выход из неё. Сеть и шлюз создаются один раз; |
| шлюз пересоздаётся, если смотрит на другой адрес, устарел или остановлен. Модель на этой же машине (localhost) шлюз |
| видит как host.docker.internal: Docker Desktop знает этот адрес сам, а Docker на Linux получает его ключом |
| ``--add-host host.docker.internal:host-gateway`` (там сервер модели должен слушать не только 127.0.0.1, а 0.0.0.0 или |
| адрес моста docker0). Модель по https шлюз вызывает по https; агенту он отвечает по http внутри сети.""" |
| if docker("network", "inspect", NETWORK).returncode != 0: |
| docker("network", "create", "--internal", NETWORK, check=True) |
| url = urlsplit(base_url) |
| host = "host.docker.internal" if url.hostname in ("localhost", "127.0.0.1", "::1") else url.hostname |
| tls = url.scheme == "https" |
| port = url.port or (443 if tls else 80) |
| label = f"{url.scheme}://{host}:{port} {GATE_VERSION}" |
| state = docker("inspect", "-f", '{{.State.Running}} {{index .Config.Labels "workpermit.target"}}', GATE) |
| if state.returncode != 0 or state.stdout.strip() != f"true {label}": |
| docker("rm", "-f", GATE) |
| docker("run", "-d", "--name", GATE, "--label", f"workpermit.target={label}", "--add-host", "host.docker.internal:host-gateway", |
| "-e", f"GATE_HOST={host}", "-e", f"GATE_PORT={port}", "-e", f"GATE_TLS={1 if tls else 0}", |
| "--entrypoint", "node", image, "-e", (HERE / "gate.js").read_text(encoding="utf-8"), check=True) |
| docker("network", "connect", NETWORK, GATE, check=True) |
| path = url.path.rstrip("/") |
| return f"http://{GATE}:{port}{path if path.endswith('/v1') else path + '/v1'}" |
|
|
|
|
| def start_desk(folder: Path, task: dict, image: str) -> str: |
| """Серверы MCP задачи в своём контейнере: агенту видны их инструменты, но не код двойников и не файл состояния.""" |
| name = f"workpermit-desk-{uuid.uuid4().hex[:12]}" |
| state = folder / "desk" |
| state.mkdir(parents=True, exist_ok=True) |
| args = ["run", "-d", "--name", name, "--network", NETWORK, "-v", f"{state}:/state", "-v", f"{HERE / 'desk'}:/desk:ro", |
| "--entrypoint", "python3", image, "/desk/server.py", "--port", str(DESK_PORT), "--state", "/state", |
| "--time-zone", task.get("time_zone") or "Europe/Moscow"] |
| if task.get("system") in SYSTEMS: |
| args += ["--system", task["system"]] |
| docker(*args, check=True) |
| for _ in range(120): |
| if (state / "ready").exists(): |
| return name |
| time.sleep(0.5) |
| raise RuntimeError(f"серверы MCP не поднялись: {docker('logs', name).stderr[-2000:]}") |
|
|
|
|
| def stop_desk(folder: Path, name: str) -> None: |
| logs = docker("logs", name) |
| (folder / "desk.log").write_text(logs.stdout + logs.stderr, encoding="utf-8") |
| docker("rm", "-f", name) |
|
|
|
|
| def patch(model_url: str, model: str, desk: str, task: dict, context: int, max_tokens: int) -> str: |
| """Настройки агента: модель стенда (адрес, имя, окно, предел ответа), сжатие истории под малое окно и серверы MCP. |
| |
| Сжатие истории (``dsh-compaction-basic``) по умолчанию держит запас в 65 536 токенов сверх ответа: при окне в 64 000 |
| порог выходит отрицательным, и сжатие не срабатывает ни разу. Для малого окна документация агента велит назначить |
| запас самому: 4 096 токенов на неточность его счёта, порог тогда — 80 % окна. Модель объявлена с вводом изображений: |
| она мультимодальная, и страницы PDF агент смотрит, переведя их в картинки (poppler в контейнере).""" |
| |
| servers = ["memory", "organizer"] + ([task["system"]] if task.get("system") in SYSTEMS else []) |
| entries = "- insert:\n" + "".join(f""" - id: mcp-{server} |
| name: '@deepseek-ai/dsh-mcp-client' |
| config: |
| serverName: {server} |
| transport: streamable-http |
| url: http://{desk}:{DESK_PORT}/mcp/{server} |
| toolCallTimeoutMs: 120000 |
| failOnStartupError: true |
| """ for server in servers) |
| return f"""- id: compaction-basic |
| name: '@deepseek-ai/dsh-compaction-basic' |
| config: |
| headroomTokens: 4096 |
| maxTokens: {max_tokens} |
| - id: agent-default-model |
| name: '@deepseek-ai/dsh-agent-default-model' |
| config: |
| provider: workpermit-model |
| model: '{model}' |
| - id: llm-pi-ai |
| name: '@deepseek-ai/dsh-llm-pi-ai' |
| config: |
| providers: |
| workpermit-model: |
| displayName: WorkPermit model |
| api: openai-completions |
| baseURL: {model_url} |
| apiKeyEnv: {KEY_ENV} |
| models: |
| - id: '{model}' |
| name: WorkPermit model |
| contextWindow: {context} |
| maxTokens: {max_tokens} |
| reasoningEfforts: false |
| input: [text, image] |
| {entries}""" |
|
|
|
|
| def turn(text: str, session: str | None, folder: Path, image: str, timeout: float) -> tuple[str, float, str | None]: |
| """Один ход агента в контейнере над папками задачи: события прогона, время и причина сбоя (None — штатно). С |
| ``session`` агент продолжает сохранённую в его доме сессию. События дописываются в ``events.jsonl``.""" |
| container = f"workpermit-dsh-{uuid.uuid4().hex[:12]}" |
| command = ["docker", "run", "--rm", "-i", "--name", container, "--network", NETWORK, "-e", KEY_ENV, |
| "-v", f"{folder / 'work'}:/work", "-v", f"{folder / 'config'}:/work-config:ro", "-v", f"{folder / 'home'}:/work-home", image] |
| if session: |
| command += ["--session-id", session] |
| started = time.monotonic() |
| |
| |
| process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, |
| env={**os.environ, KEY_ENV: os.environ.get(KEY_ENV) or NO_KEY}) |
| failure = None |
| try: |
| out, err = process.communicate(text.encode("utf-8"), timeout=timeout) |
| except subprocess.TimeoutExpired: |
| failure = f"не уложился в {timeout / 60:.0f} мин" |
| docker("kill", container) |
| out, err = process.communicate() |
| elapsed = time.monotonic() - started |
| events = out.decode("utf-8", errors="replace") |
| with (folder / "events.jsonl").open("a", encoding="utf-8") as log: |
| log.write(events) |
| with (folder / "stderr.txt").open("a", encoding="utf-8") as log: |
| log.write(err.decode("utf-8", errors="replace")) |
| if failure is None and process.returncode != 0: |
| ended = read_events(events)["ended"] |
| failure = f"процесс dsh завершился с кодом {process.returncode}" + (f", ход окончен по причине «{ended}»" if ended else "") |
| return events, elapsed, failure |
|
|
|
|
| def read_events(events: str) -> dict: |
| """Итог хода по событиям: ответ, обращения к модели с токенами, причина окончания, сессия и вызовы средств агента.""" |
| result = {"answer": "", "calls": 0, "prompt": 0, "completion": 0, "ended": None, "session": None, "tools": []} |
| for line in events.splitlines(): |
| try: |
| node = json.loads(line) |
| except ValueError: |
| continue |
| if not isinstance(node, dict): |
| continue |
| kind = node.get("type") |
| if kind == "final": |
| result["answer"] = node.get("text") or "" |
| elif kind == "status" and node.get("phase") == "step_end": |
| usage = node.get("usage") or {} |
| result["calls"] += 1 |
| result["prompt"] += usage.get("inputTokens") or 0 |
| result["completion"] += usage.get("outputTokens") or 0 |
| elif kind == "status" and node.get("phase") == "turn_end": |
| result["ended"] = (node.get("reason") or {}).get("kind") |
| elif kind == "session": |
| result["session"] = node.get("sessionId") or result["session"] |
| elif kind == "tool_call": |
| result["tools"].append((node.get("tool") or "", json.dumps(node.get("input"), ensure_ascii=False))) |
| return result |
|
|
|
|
| |
|
|
| def snapshot(work: Path) -> dict[str, str]: |
| """Документы рабочей папки с хешами; служебные скрипты агента не в счёт.""" |
| return {p.relative_to(work).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest() |
| for p in work.rglob("*") if p.is_file() and p.suffix.lower() in DELIVERED} |
|
|
|
|
| def asked(answer: str, before: dict, after: dict) -> bool: |
| """Вопрос человеку: ответ кончается вопросительным знаком, и ни один документ папки не появился и не изменился.""" |
| lines = [line for line in answer.split("\n") if line.strip()] |
| last = lines[-1].strip().rstrip("*_ ") if lines else "" |
| return last.endswith("?") and all(before.get(path) == sha for path, sha in after.items()) |
|
|
|
|
| def add_file(record: dict, folder: Path, name: str, data: bytes) -> None: |
| """Выданный файл — в ``files/`` папки задачи под безопасным именем; запись — с именем, как его видит человек.""" |
| safe = "_".join("".join("_" if c in INVALID else c for c in part) for part in name.replace("\\", "/").split("/")) |
| relative, n = f"files/{safe}", 2 |
| while any(f["path"] == relative for f in record["files"]): |
| stem, suffix = os.path.splitext(safe) |
| relative, n = f"files/{stem} ({n}){suffix}", n + 1 |
| (folder / relative).parent.mkdir(parents=True, exist_ok=True) |
| (folder / relative).write_bytes(data) |
| record["files"].append({"name": name, "path": relative, "sha256": hashlib.sha256(data).hexdigest()}) |
|
|
|
|
| def organizer(state_file: Path) -> dict: |
| """Органайзер после задачи в том же виде, что у любой системы: напоминания, автоматизации, задачи доски, заметки.""" |
| data = json.loads(state_file.read_text(encoding="utf-8")) if state_file.exists() else {} |
|
|
| def job(item: dict) -> dict: |
| return {"title": item["text"], "text": item["text"], "at_local": item["at"], "local_time": item["at"][11:16], |
| "recurring": item["repeat"] != "none", "cron": None, "repeat": item["repeat"]} |
|
|
| return {"reminders": [job(x) for x in data.get("reminders", [])], "automations": [job(x) for x in data.get("automations", [])], |
| "board_tasks": [{"title": t["title"], "text": t.get("description") or "", "due_local": t.get("due")} for t in data.get("board_tasks", [])], |
| "notes": [{"title": n["title"], "text": n["text"]} for n in data.get("notes", [])]} |
|
|
|
|
| def actions(tools: list[tuple[str, str]], calls_file: Path) -> list[dict]: |
| """Действия агента по порядку. Выдача пишется только у подключённой системы: её данных нет в материалах задачи, и без |
| выдачи судья счёл бы выдумкой то, что агент прочёл в двойнике.""" |
| calls = [json.loads(line) for line in calls_file.read_text(encoding="utf-8").splitlines() if line.strip()] if calls_file.exists() else [] |
| used = [False] * len(calls) |
| result = [] |
| for name, arguments in tools: |
| action = {"kind": "shell" if name == "bash" else "tool", "name": name, "arguments": arguments} |
| if name.startswith("mcp__"): |
| for i, call in enumerate(calls): |
| if not used[i] and name == f"mcp__{call['server']}__{call['tool']}": |
| used[i] = True |
| if call["server"] in SYSTEMS: |
| action["result"] = call["result"] |
| break |
| result.append(action) |
| return result |
|
|
|
|
| def run_task(task: dict, folder: Path, args, model_url: str) -> dict: |
| record = {"task_id": task["id"], "system": SYSTEM, "status": "completed", "asked": False, "answer": "", "turns": [], "files": [], |
| "actions": [], "storage_after": [], "state": None, "started": None, "seconds": 0.0, "model_calls": 0, |
| "prompt_tokens": 0, "completion_tokens": 0, "error": None} |
| work, config = folder / "work", folder / "config" |
| for sub in (work, config, folder / "home"): |
| sub.mkdir(parents=True, exist_ok=True) |
|
|
| inputs: dict[str, tuple[str, str]] = {} |
|
|
| def place(relative: str, file: dict) -> None: |
| target = work / relative |
| target.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copyfile(file["path"], target) |
| inputs[relative] = (file["name"], file["sha256"]) |
|
|
| for name, files in task["bases"]: |
| for file in files: |
| place(f"База знаний «{name}»/{file['name']}", file) |
| for file in task["my"]: |
| place(f"Мои файлы/{file['name']}", file) |
|
|
| desk = start_desk(folder, task, args.image) |
| tools: list[tuple[str, str]] = [] |
| try: |
| (config / "patch.yml").write_text(patch(model_url, args.model, desk, task, args.context, args.max_tokens), encoding="utf-8") |
| record["started"] = _now(task.get("time_zone")).isoformat(timespec="seconds") |
| sessions: dict[str, str] = {} |
| failure = None |
|
|
| def one(text: str, chat: str, is_reply: bool) -> bool: |
| nonlocal failure |
| before = snapshot(work) |
| events, seconds, error = turn(text, sessions.get(chat), folder, args.image, args.turn_minutes * 60) |
| step = read_events(events) |
| if step["session"]: |
| sessions[chat] = step["session"] |
| tools.extend(step["tools"]) |
| record["model_calls"] += step["calls"] |
| record["prompt_tokens"] += step["prompt"] |
| record["completion_tokens"] += step["completion"] |
| question = asked(step["answer"], before, snapshot(work)) |
| record["turns"].append({"text": text, "answer": step["answer"], "asked": question, "seconds": round(seconds, 1), "reply": is_reply}) |
| failure = error or (None if step["answer"].strip() else "агент не дал ответа" + (f" («{step['ended']}»)" if step["ended"] else "")) |
| return question |
|
|
| for index, message in enumerate(task["messages"]): |
| for file in message["attachments"]: |
| place(f"Вложения/{file['name']}", file) |
| question = one(request(task, message), message["chat"], False) |
| reply = reply_after(task, index) |
| rounds = 0 |
| while reply is not None and question and failure is None and rounds < 2: |
| question = one(reply, message["chat"], True) |
| rounds += 1 |
| if failure is not None: |
| break |
| finally: |
| stop_desk(folder, desk) |
|
|
| last = record["turns"][-1] if record["turns"] else None |
| record["seconds"] = round(sum(t["seconds"] for t in record["turns"]), 1) |
| record["answer"] = last["answer"] if last else "" |
| record["asked"] = bool(last and last["asked"]) |
| record["status"] = "failed" if failure else "asked" if record["asked"] else "completed" |
| record["error"] = failure |
|
|
| for path in sorted(p for p in work.rglob("*") if p.is_file()): |
| relative = path.relative_to(work).as_posix() |
| data = path.read_bytes() |
| sha = hashlib.sha256(data).hexdigest() |
| if relative in inputs: |
| record["storage_after"].append({"name": inputs[relative][0], "sha256": sha}) |
| if sha != inputs[relative][1]: |
| add_file(record, folder, inputs[relative][0], data) |
| elif path.suffix.lower() in DELIVERED: |
| add_file(record, folder, relative, data) |
| record["state"] = organizer(folder / "desk" / "state.json") |
| record["actions"] = actions(tools, folder / "desk" / "calls.jsonl") |
| return record |
|
|
|
|
| def _now(zone: str | None) -> datetime: |
| try: |
| from zoneinfo import ZoneInfo |
| return datetime.now(ZoneInfo(zone)) if zone else datetime.now().astimezone() |
| except Exception: |
| return datetime.now().astimezone() |
|
|
|
|
| def write_manifest(root: Path, args: argparse.Namespace, task_ids: list[str]) -> str | None: |
| """Сведения о прогоне, ``run.json``: прогон идёт по частям (категория за категорией, продолжение после сбоя), поэтому |
| запуск в ту же папку дописывает свои задачи и сохраняет начало первого запуска, по нему сайт называет дату прогона. |
| Модель и образ агента у прогона одни: запуск с другими в ту же папку смешал бы ответы в одном итоге и отклоняется. |
| Возвращает причину отказа или None.""" |
| path = root / "run.json" |
| earlier = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {} |
| for key, value, title in (("model", args.model, "моделью"), ("image", args.image, "образом агента")): |
| if earlier.get(key) not in (None, value): |
| return (f"прогон в {root} начат с {title} {earlier[key]}, а сейчас задан {value}: для другой модели или образа " |
| f"агента начните новый прогон (--name)") |
| tasks = list(dict.fromkeys([*earlier.get("tasks", []), *task_ids])) |
| path.write_text(json.dumps({"system": SYSTEM, "model": args.model, "image": args.image, "context": args.context, |
| "max_tokens": args.max_tokens, |
| "started": earlier.get("started") or datetime.now().astimezone().isoformat(timespec="seconds"), |
| "tasks": tasks}, ensure_ascii=False, indent=1), encoding="utf-8") |
| return None |
|
|
|
|
| def main(argv: list[str]) -> int: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("dataset") |
| parser.add_argument("runs") |
| parser.add_argument("--base-url", default=os.environ.get("WORKPERMIT_MODEL_URL") or None, |
| help="адрес модели, совместимый с OpenAI: http://host:8000/v1; по умолчанию WORKPERMIT_MODEL_URL") |
| parser.add_argument("--model", default=os.environ.get("WORKPERMIT_MODEL") or None, help="имя модели; по умолчанию WORKPERMIT_MODEL") |
| parser.add_argument("--name", default=datetime.now().strftime("%Y%m%d")) |
| parser.add_argument("--only", help="задачи по имени или номеру через запятую; номер категории берёт её целиком") |
| parser.add_argument("--again", action="store_true", help="прогнать заново задачи с готовой записью") |
| parser.add_argument("--image", default=IMAGE) |
| parser.add_argument("--context", type=int, default=64_000, help="окно модели, токенов") |
| parser.add_argument("--max-tokens", type=int, default=8_192, help="предел ответа модели за обращение") |
| parser.add_argument("--turn-minutes", type=float, default=90, help="срок одного сообщения: страховка от зависания") |
| args = parser.parse_args(argv[1:]) |
| if not args.base_url or not args.model: |
| parser.error("модель не задана: --base-url и --model или переменные WORKPERMIT_MODEL_URL и WORKPERMIT_MODEL") |
|
|
| try: |
| ready = docker("image", "inspect", args.image) |
| except FileNotFoundError: |
| print("Docker не найден: нужен Docker Desktop или Docker Engine 20.10+ в PATH.", file=sys.stderr) |
| return 2 |
| if ready.returncode != 0: |
| print(f"Нет образа {args.image}: соберите его командой\n docker build -t {args.image} {HERE}\n{ready.stderr.strip()}", file=sys.stderr) |
| return 2 |
| if KEY_ENV not in os.environ: |
| print(f"Переменная {KEY_ENV} не задана: агент обратится к модели с ключом «{NO_KEY}», его принимает сервер без ключа.", |
| file=sys.stderr) |
|
|
| only = [o.strip() for o in args.only.split(",")] if args.only else None |
| tasks = [t for t in load_tasks(Path(args.dataset)) |
| if only is None or any(o in (t["id"], t["number"]) or t["number"].startswith(o + ".") for o in only)] |
| root = Path(args.runs) / args.name / SYSTEM |
| root.mkdir(parents=True, exist_ok=True) |
| refusal = write_manifest(root, args, [t["id"] for t in tasks]) |
| if refusal: |
| print(refusal, file=sys.stderr) |
| return 2 |
| model_url = model_gate(args.base_url, args.image) |
| print(f"{SYSTEM}: задач {len(tasks)} → {root.resolve()}") |
| failed = 0 |
| for task in tasks: |
| folder = root / task["id"] |
| if (folder / "record.json").exists() and not args.again: |
| print(f"{task['number']} {task['id']}: запись уже есть") |
| continue |
| |
| if folder.exists(): |
| folder.rename(folder.with_name(f"{folder.name}.{datetime.now():%Y%m%d-%H%M%S}")) |
| folder.mkdir(parents=True) |
| try: |
| record = run_task(task, folder, args, model_url) |
| except Exception as error: |
| record = {"task_id": task["id"], "system": SYSTEM, "status": "failed", "asked": False, "answer": "", "turns": [], "files": [], |
| "actions": [], "storage_after": [], "state": None, "started": None, "seconds": 0.0, "model_calls": 0, |
| "prompt_tokens": 0, "completion_tokens": 0, "error": f"{type(error).__name__}: {error}"} |
| (folder / "record.json").write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8") |
| failed += record["status"] == "failed" |
| print(f"{task['number']} {task['id']}: {record['status']}, {record['seconds']} с, обращений {record['model_calls']}, " |
| f"файлов {len(record['files'])}" + (f" — {record['error']}" if record["error"] else "")) |
| print(f"{SYSTEM}: готово, сбоев {failed}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main(sys.argv)) |
|
|
