Publish Needle Pi coding-agent fine-tune

Native Needle checkpoint, tokenizer, model card, 1,500-example corpus, reproducible generator, metrics, and Pi router integration.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cactus Compute
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,128 @@
+---
+license: mit
+library_name: jax
+pipeline_tag: text-generation
+base_model: Cactus-Compute/needle
+language:
+- en
+tags:
+- needle
+- function-calling
+- tool-use
+- coding-agent
+- pi-coding-agent
+- jax
+- flax
+- encoder-decoder
+- on-device
+model-index:
+- name: Needle Pi Coding Agent
+  results:
+  - task:
+      type: text-generation
+      name: Pi tool calling
+    dataset:
+      name: Held-out Pi coding tools
+      type: pi-tools-held-out
+    metrics:
+    - type: exact_match
+      value: 0.8
+      name: Exact tool-call match
+    - type: f1
+      value: 0.8
+      name: Tool-call F1
+---
+
+# Needle Pi Coding Agent
+
+A 26.3M-parameter [Cactus Needle](https://huggingface.co/Cactus-Compute/needle) fine-tune for routing coding-agent intents into Pi's four built-in tools: `read`, `bash`, `edit`, and `write`.
+
+It is designed as a small parser/router, not a knowledge engine. An upstream planner should provide concrete paths, commands, content, or replacements; this model selects the tool and copies those arguments into a structured call.
+
+## Results
+
+Evaluation used a held-out, balanced 40-example test set with 10 examples per tool.
+
+| Metric | Base Needle | This fine-tune |
+|---|---:|---:|
+| Exact match | 27.5% | **80.0%** |
+| Tool-call F1 | 28.95% | **80.0%** |
+| Tool-name F1 | 88.0% | **100.0%** |
+| JSON parse rate | 82.5% | **100.0%** |
+| Argument accuracy | 32.35% | **80.0%** |
+
+Exact matches by tool improved from `read 8/10, bash 2/10, edit 0/10, write 1/10` to `read 9/10, bash 8/10, edit 9/10, write 6/10`.
+
+These are local single-run measurements, not an external benchmark. See [`metrics.json`](metrics.json) for machine-readable results.
+
+## Training
+
+- Base: `Cactus-Compute/needle`
+- Examples: 1,500 (`bash`: 450; `read`, `edit`, `write`: 350 each)
+- Split: 1,420 train / 40 validation / 40 test
+- Epochs: 1
+- Batch size: 32
+- Training steps: 22
+- Optimizer learning rates: Adam `3e-5`, Muon `0.02`
+- Checkpoint-selection validation exact match: 70.0%
+- Synthetic-data generator: Codex CLI, with strict schema, grounding, and deduplication validation
+
+The additional bash data emphasizes parsing fully specified arbitrary shell commands, including quoting, flags, environment variables, pipelines, redirects, subshells, and multiline commands. The model is not expected to invent specialist commands from vague goals.
+
+## Usage
+
+Clone the [Needle repository](https://github.com/cactus-compute/needle), install it, then download this repository:
+
+```bash
+hf download theabbie/needle-pi-coding-agent --local-dir needle-pi-coding-agent
+```
+
+```python
+import json
+from needle import SimpleAttentionNetwork, generate, get_tokenizer, load_checkpoint
+
+params, config = load_checkpoint("needle-pi-coding-agent/needle-pi-coding-agent.pkl")
+model = SimpleAttentionNetwork(config)
+
+tools = json.loads(open("needle-pi-coding-agent/training/pi_tools.json").read())
+result = generate(
+    model,
+    params,
+    get_tokenizer(),
+    query="Run bash command: curl -s https://api.ipify.org",
+    tools=json.dumps(tools, separators=(",", ":")),
+    stream=False,
+)
+print(result)
+# [{"name":"bash","arguments":{"command":"curl -s https://api.ipify.org"}}]
+```
+
+The bundled [`integration/pi_tool_router.py`](integration/pi_tool_router.py) accepts this JSON on standard input:
+
+```json
+{"intent":"Run bash command: curl -s https://api.ipify.org","tools":[...]}
+```
+
+and emits a JSON array containing the selected call.
+
+## Included artifacts
+
+- `needle-pi-coding-agent.pkl`: best native Needle/JAX checkpoint
+- `config.json` and `tokenizer/`: architecture and tokenizer files
+- `training/pi_tools_1500.jsonl`: full 1,500-example training corpus
+- `training/pi_tools.json`: flattened schemas for Pi's built-in tools
+- `training/generate_pi_dataset.py`: resumable, atomically persisted generator
+- `training/codex_client.py`: clean Codex CLI text-generation adapter
+- `training/pi_tools_1500.progress.json`: final generation manifest
+- `integration/pi_tool_router.py`: minimal stdin/stdout router used by the Pi provider prototype
+
+## Limitations
+
+- This is a focused single-shot tool router, not a conversational language model.
+- Exact edit extraction is strongest when the planner explicitly supplies the `edits` array with `oldText` and `newText` values.
+- Long or whitespace-sensitive write/edit payloads can still be copied imperfectly.
+- Shell commands are executed by the surrounding agent runtime; this model does not provide sandboxing or command safety.
+
+## License and attribution
+
+MIT. Based on [Cactus-Compute/needle](https://huggingface.co/Cactus-Compute/needle) and the [Needle source repository](https://github.com/cactus-compute/needle).

config.json

@@ -0,0 +1,5 @@
+{
+  "library_name": "jax",
+  "model_type": "custom",
+  "architectures": ["SimpleAttentionNetwork"]
+}

integration/pi_tool_router.py

@@ -0,0 +1,35 @@
+"""Route a short tool intent to Pi's live tool schemas with Needle."""
+
+import json
+import sys
+from pathlib import Path
+
+from needle import SimpleAttentionNetwork, generate, get_tokenizer, load_checkpoint
+
+
+MODEL_ROOT = Path(__file__).resolve().parents[1]
+params, config = load_checkpoint(MODEL_ROOT / "needle-pi-coding-agent.pkl")
+model = SimpleAttentionNetwork(config)
+tokenizer = get_tokenizer()
+
+
+def main() -> None:
+    request = json.load(sys.stdin)
+    result = generate(
+        model,
+        params,
+        tokenizer,
+        query=request["intent"],
+        tools=json.dumps(request["tools"], separators=(",", ":")),
+        stream=False,
+    )
+    calls = json.loads(result)
+    if not isinstance(calls, list) or not calls:
+        raise ValueError("Needle returned no tool calls")
+    # Exa plans one step at a time. Running only Needle's first call keeps Pi's
+    # real tool result in the loop before either model chooses another action.
+    json.dump(calls[:1], sys.stdout, separators=(",", ":"))
+
+
+if __name__ == "__main__":
+    main()

metrics.json

@@ -0,0 +1,23 @@
+{
+  "evaluation_split": {
+    "total": 40,
+    "per_tool": 10,
+    "tools": ["read", "bash", "edit", "write"]
+  },
+  "base_model": {
+    "call_f1": 0.2895,
+    "name_f1": 0.88,
+    "exact_match": 0.275,
+    "parse_rate": 0.825,
+    "arguments_accuracy": 0.3235,
+    "exact_by_tool": {"read": 0.8, "bash": 0.2, "edit": 0.0, "write": 0.1}
+  },
+  "fine_tuned_model": {
+    "call_f1": 0.8,
+    "name_f1": 1.0,
+    "exact_match": 0.8,
+    "parse_rate": 1.0,
+    "arguments_accuracy": 0.8,
+    "exact_by_tool": {"read": 0.9, "bash": 0.8, "edit": 0.9, "write": 0.6}
+  }
+}

needle-pi-coding-agent.pkl

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

tokenizer/needle.model

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

training/codex_client.py

@@ -0,0 +1,58 @@
+"""Small text-generation adapter backed by `codex exec`."""
+
+from pathlib import Path
+from types import SimpleNamespace
+import subprocess
+import tempfile
+
+
+class CodexModels:
+    def generate_content(self, model, contents, config=None):
+        del model, config
+        with tempfile.TemporaryDirectory(prefix="needle-codex-") as temp_dir:
+            output_path = Path(temp_dir) / "response.txt"
+            process = subprocess.run(
+                [
+                    "codex",
+                    "exec",
+                    "--ephemeral",
+                    "--sandbox",
+                    "read-only",
+                    "--skip-git-repo-check",
+                    "--color",
+                    "never",
+                    "--output-last-message",
+                    str(output_path),
+                    "-",
+                ],
+                input=contents,
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                timeout=600,
+                check=False,
+            )
+            if process.returncode != 0:
+                detail = (process.stderr or process.stdout).strip()[-4000:]
+                raise RuntimeError(f"codex exec failed ({process.returncode}): {detail}")
+            if not output_path.exists():
+                raise RuntimeError("codex exec produced no final-response file")
+            text = output_path.read_text(encoding="utf-8").strip()
+            if not text:
+                raise RuntimeError("codex exec produced an empty final response")
+            return SimpleNamespace(text=text)
+
+
+class CodexClient:
+    def __init__(self):
+        self.models = CodexModels()
+
+
+class CodexClientPool:
+    """Matches the tiny client-pool interface used by Needle's generator."""
+
+    def __init__(self):
+        self._client = CodexClient()
+
+    def get(self):
+        return self._client

training/generate_pi_dataset.py

@@ -0,0 +1,291 @@
+"""Resumably extend Pi's tool-routing dataset with harder parser examples."""
+
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any
+import json
+import os
+import re
+import time
+
+from codex_client import CodexClientPool
+
+
+ROOT = Path(__file__).parent
+TOOLS = json.loads((ROOT / "pi_tools.json").read_text(encoding="utf-8"))
+SEED_OUTPUT = ROOT / "pi_tools_1200.jsonl"
+OUTPUT = ROOT / "pi_tools_1500.jsonl"
+PROGRESS = ROOT / "pi_tools_1500.progress.json"
+TARGETS = {"read": 350, "bash": 450, "edit": 350, "write": 350}
+TOTAL_TARGET = sum(TARGETS.values())
+BATCH_SIZE = 25
+MAX_WORKERS = 4
+TOOL_MAP = {tool["name"]: tool for tool in TOOLS}
+TOOLS_TEXT = json.dumps(TOOLS, separators=(",", ":"), ensure_ascii=False)
+
+THEMES = [
+    "short direct requests",
+    "absolute and relative paths",
+    "spaces, quotes, unicode, and punctuation",
+    "JavaScript and TypeScript projects",
+    "Python projects",
+    "shell pipelines and redirects",
+    "configuration and environment files",
+    "multiline source code",
+    "logs, offsets, and limits",
+    "nested directories and dotfiles",
+    "URLs contrasted with local paths",
+    "realistic debugging and maintenance tasks",
+]
+
+
+def _strip_fence(text: str) -> str:
+    text = text.strip()
+    if text.startswith("```"):
+        text = text.split("\n", 1)[1] if "\n" in text else text[3:]
+    if text.endswith("```"):
+        text = text[:-3]
+    return text.strip()
+
+
+def _query_key(query: str) -> str:
+    return re.sub(r"\s+", " ", query.strip().casefold())
+
+
+def _load_existing() -> list[dict[str, Any]]:
+    source = OUTPUT if OUTPUT.exists() else SEED_OUTPUT
+    if not source.exists():
+        return []
+    records = []
+    for line_number, line in enumerate(source.read_text(encoding="utf-8").splitlines(), 1):
+        if not line.strip():
+            continue
+        try:
+            record = json.loads(line)
+            answers = json.loads(record["answers"])
+            name = answers[0]["name"]
+            if name not in TOOL_MAP:
+                raise ValueError(f"unknown tool {name}")
+            records.append(record)
+        except Exception as error:
+            raise ValueError(f"invalid existing dataset line {line_number}: {error}") from error
+    return records
+
+
+def _leaf_values(value: Any):
+    if isinstance(value, dict):
+        for child in value.values():
+            yield from _leaf_values(child)
+    elif isinstance(value, list):
+        for child in value:
+            yield from _leaf_values(child)
+    elif value is not None:
+        yield value
+
+
+def _valid_example(example: Any, expected_tool: str) -> tuple[bool, str]:
+    if not isinstance(example, dict):
+        return False, "not an object"
+    query = example.get("query")
+    answers = example.get("answers")
+    if not isinstance(query, str) or not query.strip():
+        return False, "missing query"
+    if not isinstance(answers, list) or len(answers) != 1:
+        return False, "answer count"
+    call = answers[0]
+    if not isinstance(call, dict) or call.get("name") != expected_tool:
+        return False, "wrong tool"
+    arguments = call.get("arguments")
+    if not isinstance(arguments, dict):
+        return False, "arguments"
+
+    schema = TOOL_MAP[expected_tool]["parameters"]
+    if set(arguments) - set(schema):
+        return False, "unknown argument"
+    required = {name for name, info in schema.items() if info.get("required")}
+    if required - set(arguments):
+        return False, "missing argument"
+
+    for name, value in arguments.items():
+        expected_type = schema[name]["type"]
+        if expected_type == "string" and not isinstance(value, str):
+            return False, "string type"
+        if expected_type == "number" and (not isinstance(value, (int, float)) or isinstance(value, bool)):
+            return False, "number type"
+        if expected_type == "array" and not isinstance(value, list):
+            return False, "array type"
+
+    if expected_tool == "edit":
+        edits = arguments.get("edits")
+        if not edits or not all(
+            isinstance(edit, dict)
+            and set(edit) == {"oldText", "newText"}
+            and isinstance(edit["oldText"], str)
+            and isinstance(edit["newText"], str)
+            for edit in edits
+        ):
+            return False, "edit shape"
+
+    # The router must copy values, never invent them. Require every non-empty
+    # scalar argument value to occur literally in the planner-style query.
+    for value in _leaf_values(arguments):
+        rendered = str(value)
+        if rendered and rendered not in query:
+            return False, f"ungrounded value: {rendered[:40]}"
+    return True, ""
+
+
+def _prompt(tool_name: str, count: int, batch_number: int, avoid: list[str], current_count: int) -> str:
+    theme = THEMES[(batch_number - 1) % len(THEMES)]
+    if tool_name == "edit":
+        theme = "short single-line exact replacements with diverse file types and syntax"
+    if tool_name == "bash" and current_count < 400:
+        theme = """high-complexity shell-command parsing. Invent realistic setup or maintenance scenarios such as installing X, configuring Y, launching a service, building a project, transforming files, inspecting a system, or chaining arbitrary shell steps. The query must already contain the exact complete command; the router only extracts it. Use varied quoting, flags, environment variables, pipes, redirects, subshells, and multiline commands. Do not require the router to synthesize specialist commands from vague goals"""
+    elif current_count >= 300:
+        theme = """noisy or mildly ambiguous planner messages that still contain one unambiguous tool action and every exact argument. Add natural hesitations, corrections, irrelevant context, or conversational clutter, but keep the intended call objectively recoverable"""
+    avoid_text = "\n".join(f"- {query}" for query in avoid[-30:]) or "- none"
+    tool = TOOL_MAP[tool_name]
+    return f"""Generate exactly {count} training examples for a coding-agent tool router.
+
+ALL AVAILABLE TOOLS:
+{TOOLS_TEXT}
+
+This batch must call only `{tool_name}`:
+{json.dumps(tool, separators=(',', ':'), ensure_ascii=False)}
+
+Batch theme: {theme}
+
+Rules:
+- Return one valid JSON array and nothing else.
+- Every item is exactly {{"query":"...","answers":[{{"name":"{tool_name}","arguments":{{...}}}}]}}.
+- Exactly one call per example and exactly {count} examples.
+- The query is a short, explicit planner intent, not a casual end-user request.
+- Include every argument value literally and exactly in the query. Never infer, shorten, repair, normalize, or invent a value.
+- Preserve shell commands, paths, file content, oldText, newText, quoting, escapes, whitespace, and newlines exactly.
+- Use only declared parameters and include every required parameter.
+- Make examples meaningfully different, not template-like substitutions.
+- For `bash`, `command` must contain the complete executable command, not merely a URL, filename, or description.
+- For `read`, paths are filesystem paths; never use a web URL as a path.
+- For `edit`, `edits` is a non-empty array of objects with only `oldText` and `newText` strings.
+- For `edit`, keep every oldText and newText on one line, and place each exact value directly in the query without Markdown escaping or a code fence.
+- For `write`, `content` is the complete file content and appears verbatim in the query.
+- Noise may surround an action, but never make the expected arguments unknowable or require specialist domain knowledge.
+
+Do not repeat these earlier queries:
+{avoid_text}
+"""
+
+
+def _generate_batch(tool_name: str, count: int, batch_number: int, avoid: list[str], current_count: int):
+    response = CodexClientPool().get().models.generate_content(
+        model="codex-cli",
+        contents=_prompt(tool_name, count, batch_number, avoid, current_count),
+        config={"temperature": 0.8, "max_output_tokens": 16384},
+    )
+    parsed = json.loads(_strip_fence(response.text))
+    if not isinstance(parsed, list):
+        raise ValueError("response is not an array")
+    return tool_name, parsed
+
+
+def _persist(records: list[dict[str, Any]], failures: dict[str, int]) -> Counter:
+    counts = Counter()
+    lines = []
+    for record in records:
+        name = json.loads(record["answers"])[0]["name"]
+        counts[name] += 1
+        lines.append(json.dumps(record, ensure_ascii=False))
+
+    output_tmp = OUTPUT.with_suffix(OUTPUT.suffix + ".tmp")
+    output_tmp.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8")
+    os.replace(output_tmp, OUTPUT)
+
+    state = {
+        "targets": TARGETS,
+        "total": len(records),
+        "per_tool": {name: counts[name] for name in TOOL_MAP},
+        "failures": failures,
+        "updated_at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+        "complete": all(counts[name] >= TARGETS[name] for name in TOOL_MAP),
+    }
+    progress_tmp = PROGRESS.with_suffix(PROGRESS.suffix + ".tmp")
+    progress_tmp.write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
+    os.replace(progress_tmp, PROGRESS)
+    return counts
+
+
+def main() -> None:
+    records = _load_existing()
+    seen = {_query_key(record["query"]) for record in records}
+    failures = {name: 0 for name in TOOL_MAP}
+    counts = _persist(records, failures)
+    print(f"Resuming at {len(records)}/{TOTAL_TARGET}: {dict(counts)}", flush=True)
+
+    round_number = 0
+    while any(counts[name] < TARGETS[name] for name in TOOL_MAP):
+        round_number += 1
+        jobs = {}
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as pool:
+            for name in TOOL_MAP:
+                remaining = TARGETS[name] - counts[name]
+                if remaining <= 0:
+                    continue
+                count = min(BATCH_SIZE, remaining)
+                prior = [
+                    record["query"] for record in records
+                    if json.loads(record["answers"])[0]["name"] == name
+                ]
+                batch_number = (counts[name] // BATCH_SIZE) + 1
+                future = pool.submit(_generate_batch, name, count, batch_number, prior, counts[name])
+                jobs[future] = name
+
+            for future in as_completed(jobs):
+                scheduled_name = jobs[future]
+                try:
+                    name, examples = future.result()
+                    accepted = 0
+                    rejected = Counter()
+                    remaining = TARGETS[name] - counts[name]
+                    for example in examples:
+                        valid, reason = _valid_example(example, name)
+                        key = _query_key(example.get("query", "")) if isinstance(example, dict) else ""
+                        if not valid:
+                            rejected[reason] += 1
+                            continue
+                        if key in seen:
+                            rejected["duplicate"] += 1
+                            continue
+                        if accepted >= remaining:
+                            break
+                        answers = example["answers"]
+                        records.append({
+                            "query": example["query"],
+                            "tools": TOOLS_TEXT,
+                            "answers": json.dumps(answers, separators=(",", ":"), ensure_ascii=False),
+                            "source": "synth-codex-cli",
+                            "model": "codex-cli",
+                        })
+                        seen.add(key)
+                        accepted += 1
+                    failures[name] = 0 if accepted else failures[name] + 1
+                    counts = _persist(records, failures)
+                    print(
+                        f"{name}: +{accepted}, rejected={dict(rejected)}, "
+                        f"progress={counts[name]}/{TARGETS[name]}, total={len(records)}/{TOTAL_TARGET}",
+                        flush=True,
+                    )
+                except Exception as error:
+                    failures[scheduled_name] += 1
+                    _persist(records, failures)
+                    print(f"{scheduled_name} batch failed (progress preserved): {error}", flush=True)
+
+        if max(failures.values()) >= 5:
+            raise RuntimeError(f"five consecutive failures; rerun to resume: {failures}")
+
+    counts = _persist(records, failures)
+    print(json.dumps({"output": str(OUTPUT), "total": len(records), "per_tool": dict(counts)}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

training/pi_tools.json

@@ -0,0 +1,35 @@
+[
+  {
+    "name": "read",
+    "description": "Read the contents of a file. Supports text files and images. Use offset and limit for large text files.",
+    "parameters": {
+      "path": {"type": "string", "description": "Path to the file to read (relative or absolute)", "required": true},
+      "offset": {"type": "number", "description": "Line number to start reading from (1-indexed)", "required": false},
+      "limit": {"type": "number", "description": "Maximum number of lines to read", "required": false}
+    }
+  },
+  {
+    "name": "bash",
+    "description": "Execute a bash command in the current working directory and return stdout and stderr.",
+    "parameters": {
+      "command": {"type": "string", "description": "Exact Bash command to execute", "required": true},
+      "timeout": {"type": "number", "description": "Optional timeout in seconds", "required": false}
+    }
+  },
+  {
+    "name": "edit",
+    "description": "Edit one file using one or more exact, non-overlapping text replacements.",
+    "parameters": {
+      "path": {"type": "string", "description": "Path to the file to edit (relative or absolute)", "required": true},
+      "edits": {"type": "array", "description": "Array of objects with exact oldText and replacement newText strings", "required": true}
+    }
+  },
+  {
+    "name": "write",
+    "description": "Create or completely overwrite a file, creating parent directories automatically.",
+    "parameters": {
+      "path": {"type": "string", "description": "Path to the file to write (relative or absolute)", "required": true},
+      "content": {"type": "string", "description": "Complete content to write to the file", "required": true}
+    }
+  }
+]

training/pi_tools_1500.progress.json

@@ -0,0 +1,23 @@
+{
+  "targets": {
+    "read": 350,
+    "bash": 450,
+    "edit": 350,
+    "write": 350
+  },
+  "total": 1500,
+  "per_tool": {
+    "read": 350,
+    "bash": 450,
+    "edit": 350,
+    "write": 350
+  },
+  "failures": {
+    "read": 0,
+    "bash": 0,
+    "edit": 0,
+    "write": 0
+  },
+  "updated_at": "2026-07-13T11:05:43+0530",
+  "complete": true
+}