@tangle-network/starter-foundry 0.5.4 → 0.7.0

package/registry/families/ros2-node-py/manifest.json

@@ -0,0 +1,197 @@
+{
+  "id": "ros2-node-py",
+  "description": "ROS 2 (Jazzy / Humble) Python node package. ament_python build, rclpy, a minimal cmd_vel publisher + /odom subscriber, and a launch file. For mobile robots, manipulator arms, Nav2 stacks, and any robotics product where Python is the glue between drivers and planners.",
+  "tags": [
+    "ros2",
+    "rclpy",
+    "robotics",
+    "python",
+    "ament-python"
+  ],
+  "taxonomy": {
+    "language": "python",
+    "runtime": "ros2",
+    "surface": "robot-node"
+  },
+  "defaults": {
+    "projectType": "robot-node",
+    "packageName": "starter_foundry_ros2",
+    "rosDistro": "jazzy",
+    "nodeName": "minimal_publisher",
+    "cmdVelTopic": "/cmd_vel",
+    "odomTopic": "/odom",
+    "linearX": 0.2,
+    "angularZ": 0.0,
+    "publishRateHz": 10
+  },
+  "files": [
+    {
+      "source": "files/package.xml",
+      "target": "package.xml"
+    },
+    {
+      "source": "files/setup.py",
+      "target": "setup.py"
+    },
+    {
+      "source": "files/setup.cfg",
+      "target": "setup.cfg"
+    },
+    {
+      "source": "files/resource-marker",
+      "target": "resource/{{packageName}}"
+    },
+    {
+      "source": "files/validate-ros2-py.mjs",
+      "target": "validate-ros2-py.mjs"
+    },
+    {
+      "source": "files/README-ros2.md",
+      "target": "docs/ros2.md"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "package.xml"
+    },
+    {
+      "type": "file-exists",
+      "path": "setup.py"
+    },
+    {
+      "type": "file-exists",
+      "path": "resource/{{packageName}}"
+    },
+    {
+      "type": "file-exists",
+      "path": "{{packageName}}/__init__.py"
+    },
+    {
+      "type": "file-exists",
+      "path": "{{packageName}}/minimal_publisher.py"
+    },
+    {
+      "type": "file-exists",
+      "path": "{{packageName}}/minimal_subscriber.py"
+    },
+    {
+      "type": "file-exists",
+      "path": "launch/bringup.launch.py"
+    },
+    {
+      "type": "python-compile",
+      "path": "{{packageName}}/minimal_publisher.py"
+    },
+    {
+      "type": "python-compile",
+      "path": "{{packageName}}/minimal_subscriber.py"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-ros2-py.mjs"
+      ],
+      "expect": "ros2 python node ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "source /opt/ros/{{rosDistro}}/setup.bash",
+      "colcon build --packages-select {{packageName}}",
+      "source install/setup.bash",
+      "ros2 run {{packageName}} publisher",
+      "ros2 launch {{packageName}} bringup.launch.py"
+    ],
+    "entrypoints": [
+      "{{packageName}}/minimal_publisher.py",
+      "{{packageName}}/minimal_subscriber.py",
+      "launch/bringup.launch.py",
+      "package.xml",
+      "setup.py"
+    ],
+    "preview": null,
+    "extensionPoints": [
+      "{{packageName}}/minimal_publisher.py",
+      "{{packageName}}/minimal_subscriber.py",
+      "launch/bringup.launch.py",
+      "package.xml"
+    ]
+  },
+  "keywords": [
+    "ros2",
+    "ros 2",
+    "rclpy",
+    "ros2 node python",
+    "ros2 python node",
+    "ros2 launch",
+    "ros2 publisher",
+    "ros2 subscriber",
+    "cmd_vel",
+    "ament_python",
+    "robot operating system",
+    "ros2 jazzy",
+    "ros2 humble",
+    "nav2",
+    "ros2 teleop",
+    "ros2 turtlebot"
+  ],
+  "scoring": {
+    "boost": {
+      "ros2": 5,
+      "rclpy": 5,
+      "ros2 node python": 5,
+      "ros 2": 4
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "ros2",
+      "ros 2",
+      "rclpy",
+      "ros2 node python",
+      "ros2 python node",
+      "ros2 launch",
+      "cmd_vel",
+      "ament_python"
+    ],
+    "tier2": [
+      "ros2 jazzy",
+      "ros2 humble",
+      "ros2 publisher",
+      "ros2 subscriber",
+      "nav2",
+      "ros2 turtlebot",
+      "robot operating system"
+    ],
+    "archetypes": [
+      "mobile robot controller",
+      "turtlebot driver",
+      "nav2 waypoint follower",
+      "teleop node",
+      "lidar bridge"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Attach for any ROS 2 Python node — mobile robots, manipulators, sensor bridges, Nav2 lifecycle nodes. Pick this over ros2-node-rust unless the prompt specifically asks for Rust / rclrs or hard-realtime.",
+    "firstSteps": [
+      "Install ROS 2 Jazzy (24.04) or Humble (22.04): follow https://docs.ros.org/en/{{rosDistro}}/Installation.html",
+      "Place this package inside a colcon workspace at src/{{packageName}} (the folder containing package.xml)",
+      "cd <workspace>, source /opt/ros/{{rosDistro}}/setup.bash, then colcon build --packages-select {{packageName}}",
+      "source install/setup.bash before running ros2 run / ros2 launch — the overlay does NOT chain automatically"
+    ],
+    "gotchas": [
+      "rclpy is not installable from pip — it ships with the ROS 2 binary distribution. pip install rclpy will fail. Source /opt/ros/{{rosDistro}}/setup.bash so the apt-installed rclpy is on PYTHONPATH.",
+      "ROS_DOMAIN_ID isolates DDS traffic between developers on the same LAN. Default 0 means everyone on the subnet sees your topics — set export ROS_DOMAIN_ID=42 (1-232) per workstation.",
+      "RMW middleware matters: Jazzy defaults to rmw_fastrtps_cpp, Humble also supports rmw_cyclonedds_cpp. Mixing middlewares across nodes causes silent discovery failures — align RMW_IMPLEMENTATION across all terminals.",
+      "Don't forget to source install/setup.bash after every colcon build — ROS overlays are not automatic like nvm/pyenv.",
+      "setup.py entry_points['console_scripts'] is the ONLY way `ros2 run <pkg> <script>` finds executables in ament_python. Missing entry_points = missing scripts, no warning.",
+      "launch files must live under share/{{packageName}}/launch after install — data_files in setup.py maps them. If launch files aren't found, inspect install/{{packageName}}/share/{{packageName}}/launch.",
+      "QoS profiles matter: /odom is typically BEST_EFFORT + VOLATILE, /tf_static is RELIABLE + TRANSIENT_LOCAL. Mismatched QoS between pub/sub = silent drop. Use rclpy.qos.QoSPresetProfiles.SENSOR_DATA for lidar/IMU, SYSTEM_DEFAULT for /cmd_vel.",
+      "resource/{{packageName}} is a mandatory empty marker file — ament uses it to register the package with the index. Deleting it breaks `ros2 pkg list`.",
+      "Multi-robot setups: namespace each node with `__ns:=/robot1` and remap topics with `topic:=/robot1/cmd_vel`. Hard-coded absolute topics ('/cmd_vel') break multi-robot.",
+      "Nav2 lifecycle nodes require manual state transitions. A plain Node subclass won't participate in bt_navigator — inherit from LifecycleNode and wire on_configure/on_activate if integrating with Nav2."
+    ]
+  }
+}

package/registry/families/sglang-server/files/.env.example

@@ -0,0 +1,21 @@
+# HuggingFace model id. Gated repos need HUGGING_FACE_HUB_TOKEN plus license
+# acceptance on huggingface.co.
+MODEL_ID={{modelId}}
+HUGGING_FACE_HUB_TOKEN=
+
+# SGLang listens on 30000 by default (not 8000 — update LB/firewall rules).
+PORT={{port}}
+SGLANG_URL=http://localhost:{{port}}/v1
+
+# Context length SGLang will allocate KV cache for.
+CONTEXT_LENGTH={{contextLength}}
+
+# Fraction of GPU memory reserved for static weights + KV cache.
+# 0.85 is the safe default; > 0.90 risks OOM once KV cache fills.
+MEM_FRACTION_STATIC=0.85
+
+# Tensor-parallel size. Set to your GPU count for 70B-class models.
+TP_SIZE=1
+
+# Optional bearer token; set to require Authorization on /v1/*.
+SGLANG_API_KEY=

package/registry/families/sglang-server/files/README-sglang.md

@@ -0,0 +1,60 @@
+# SGLang — operator guide
+
+SGLang is an inference engine optimized for two workloads:
+
+1. **Shared prefix traffic** — RadixAttention caches KV across requests that
+   share system prompts / few-shot examples / retrieved context.
+2. **Structured generation** — constrained decoders guarantee JSON-schema
+   and regex validity at the logit level (no retry loops).
+
+## First-run (Docker)
+
+```bash
+cp .env.example .env
+docker compose up -d
+docker compose logs -f sglang   # wait for "Uvicorn running on ..."
+curl http://localhost:{{port}}/health
+python -m src.client
+```
+
+## First-run (bare metal)
+
+```bash
+pip install "sglang[all]>=0.3.0"
+bash launch.sh
+```
+
+`launch.sh` hard-codes the `python -m sglang.launch_server` incantation with
+sensible defaults and passes `EXTRA_FLAGS` through for quick overrides.
+
+## Structured generation
+
+SGLang accepts OpenAI-compatible payloads plus a `response_format`:
+
+```python
+response = client.chat.completions.create(
+    model=MODEL_ID,
+    messages=[{"role": "user", "content": "..."}],
+    extra_body={"response_format": {"type": "json_schema", "json_schema": {...}}},
+)
+```
+
+The returned content is **guaranteed** to match the schema — SGLang masks
+logits against the grammar so the sampler can only pick valid continuations.
+For regex-shaped outputs, use `"type": "regex", "regex": "..."`.
+
+## Swapping / scaling
+
+- **Tensor parallel**: set `TP_SIZE` to GPU count for 70B models.
+- **Context length**: tune `CONTEXT_LENGTH` — larger = more KV cache = less
+  room for concurrent requests.
+- **Torch compile**: add `--enable-torch-compile` to `launch.sh`'s
+  `EXTRA_FLAGS` for ~20% lower prefill latency at the cost of ~1min startup.
+- **Quantization**: `--quantization awq` / `fp8` supported on matching weights.
+
+## Picking between SGLang, vLLM, TGI, Ollama
+
+- **SGLang**: winner on structured outputs + repeated system prompts.
+- **vLLM**: winner on raw free-text throughput at high concurrency.
+- **TGI**: Hub ecosystem, docker-first, strongest HF quant support.
+- **Ollama**: local GGUF, lowest operator overhead.

package/registry/families/sglang-server/files/client.py

@@ -0,0 +1,87 @@
+"""SGLang client — hits the OpenAI-compatible /v1/chat/completions surface
+and demonstrates JSON-schema-constrained generation (SGLang's marquee feature).
+
+Run `docker compose up -d` or `bash launch.sh` first, then:
+    python -m src.client
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+from openai import OpenAI
+
+
+SGLANG_URL = os.environ.get("SGLANG_URL", "http://localhost:{{port}}/v1")
+MODEL_ID = os.environ.get("MODEL_ID", "{{modelId}}")
+
+
+def _client() -> OpenAI:
+    # SGLang ignores the api_key unless configured to require one; a sentinel
+    # avoids the OpenAI SDK's "missing key" refusal.
+    return OpenAI(base_url=SGLANG_URL, api_key=os.environ.get("SGLANG_API_KEY", "EMPTY"))
+
+
+def chat(prompt: str) -> str:
+    """Plain OpenAI-compatible chat call."""
+    response = _client().chat.completions.create(
+        model=MODEL_ID,
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=256,
+        temperature=0.7,
+    )
+    return response.choices[0].message.content or ""
+
+
+def chat_structured(prompt: str, schema: dict) -> dict:
+    """JSON-schema-constrained generation — SGLang guarantees schema validity."""
+    response = _client().chat.completions.create(
+        model=MODEL_ID,
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=512,
+        temperature=0.0,
+        extra_body={
+            "response_format": {
+                "type": "json_schema",
+                "json_schema": {"name": "structured", "schema": schema, "strict": True},
+            },
+        },
+    )
+    content = response.choices[0].message.content or "{}"
+    return json.loads(content)
+
+
+def main() -> int:
+    print(f"-> plain chat via {SGLANG_URL}\n")
+    try:
+        print(chat("Give one sentence on RadixAttention."))
+    except Exception as exc:
+        print(f"SGLang chat failed: {exc}", file=sys.stderr)
+        print(f"Is the server running at {SGLANG_URL}?", file=sys.stderr)
+        return 1
+
+    print("\n-> JSON-schema-constrained generation")
+    schema = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"},
+            "year": {"type": "integer"},
+            "keywords": {"type": "array", "items": {"type": "string"}},
+        },
+        "required": ["name", "year", "keywords"],
+        "additionalProperties": False,
+    }
+    prompt = "Return a JSON object describing the SGLang paper with year and 3 keywords."
+    try:
+        parsed = chat_structured(prompt, schema)
+    except Exception as exc:
+        print(f"structured call failed: {exc}", file=sys.stderr)
+        return 1
+    print(json.dumps(parsed, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/registry/families/sglang-server/files/docker-compose.yml

@@ -0,0 +1,46 @@
+# SGLang inference server — RadixAttention prefix caching + constrained decoding.
+# Pin the image tag in production (lmsysorg/sglang:v0.3.6 or similar);
+# `latest` tracks fast-moving CUDA + torch bumps.
+services:
+  sglang:
+    image: lmsysorg/sglang:latest
+    container_name: {{serviceName}}
+    restart: unless-stopped
+    ports:
+      - "{{port}}:30000"
+    shm_size: 1gb
+    environment:
+      HUGGING_FACE_HUB_TOKEN: ${HUGGING_FACE_HUB_TOKEN:-}
+      HF_TOKEN: ${HUGGING_FACE_HUB_TOKEN:-}
+    command:
+      - python3
+      - -m
+      - sglang.launch_server
+      - --model-path
+      - ${MODEL_ID:-{{modelId}}}
+      - --host
+      - "0.0.0.0"
+      - --port
+      - "30000"
+      - --context-length
+      - "${CONTEXT_LENGTH:-{{contextLength}}}"
+      - --mem-fraction-static
+      - "${MEM_FRACTION_STATIC:-0.85}"
+      - --tp-size
+      - "${TP_SIZE:-1}"
+      # --enable-torch-compile cuts prefill latency but costs ~1min startup.
+    volumes:
+      - ./data:/root/.cache/huggingface
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:30000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 180s

package/registry/families/sglang-server/files/launch.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Bare-metal SGLang launch. Use this when running SGLang in a venv/conda on
+# the host instead of via docker-compose. Requires a matching CUDA toolkit.
+#
+#     pip install "sglang[all]>=0.3.0"
+#     bash launch.sh
+#
+set -euo pipefail
+
+MODEL_ID="${MODEL_ID:-{{modelId}}}"
+PORT="${PORT:-{{port}}}"
+CONTEXT_LENGTH="${CONTEXT_LENGTH:-{{contextLength}}}"
+MEM_FRACTION_STATIC="${MEM_FRACTION_STATIC:-0.85}"
+TP_SIZE="${TP_SIZE:-1}"
+
+# shellcheck disable=SC2086 # deliberately word-split extra flags
+EXTRA_FLAGS="${EXTRA_FLAGS:-}"
+
+exec python -m sglang.launch_server \
+  --model-path "$MODEL_ID" \
+  --host 0.0.0.0 \
+  --port "$PORT" \
+  --context-length "$CONTEXT_LENGTH" \
+  --mem-fraction-static "$MEM_FRACTION_STATIC" \
+  --tp-size "$TP_SIZE" \
+  $EXTRA_FLAGS

package/registry/families/sglang-server/files/requirements.txt

@@ -0,0 +1,5 @@
+# Client-side only. The SGLang server itself runs via docker-compose
+# (or via the bare-metal launch.sh).
+openai>=1.50.0
+httpx>=0.27.0
+pydantic>=2.9.0

package/registry/families/sglang-server/files/validate-sglang.mjs

@@ -0,0 +1,49 @@
+import fs from "node:fs/promises";
+
+const [compose, requirements, client, launch, envExample] = await Promise.all([
+  fs.readFile("docker-compose.yml", "utf8"),
+  fs.readFile("requirements.txt", "utf8"),
+  fs.readFile("src/client.py", "utf8"),
+  fs.readFile("launch.sh", "utf8"),
+  fs.readFile(".env.example", "utf8"),
+]);
+
+if (!compose.includes("lmsysorg/sglang")) {
+  throw new Error("docker-compose.yml missing lmsysorg/sglang image");
+}
+if (!compose.includes("sglang.launch_server")) {
+  throw new Error("docker-compose.yml must invoke sglang.launch_server");
+}
+if (!compose.includes("driver: nvidia") || !compose.includes("capabilities: [gpu]")) {
+  throw new Error("docker-compose.yml missing nvidia GPU device reservation");
+}
+if (!compose.includes("--mem-fraction-static")) {
+  throw new Error("docker-compose.yml should expose --mem-fraction-static to avoid OOM");
+}
+
+if (!requirements.includes("openai") && !requirements.includes("httpx")) {
+  throw new Error("requirements.txt needs openai or httpx for the client");
+}
+
+if (!client.includes("/v1/chat/completions") && !client.includes("chat.completions.create")) {
+  throw new Error("src/client.py must hit OpenAI-compatible /v1/chat/completions");
+}
+if (!client.includes("response_format") && !client.includes("json_schema")) {
+  throw new Error("src/client.py should demonstrate SGLang's constrained JSON generation");
+}
+
+if (!launch.includes("sglang.launch_server")) {
+  throw new Error("launch.sh must invoke python -m sglang.launch_server");
+}
+if (!launch.includes("--model-path")) {
+  throw new Error("launch.sh must pass --model-path");
+}
+
+if (!envExample.includes("MODEL_ID")) {
+  throw new Error(".env.example missing MODEL_ID");
+}
+if (!envExample.includes("MEM_FRACTION_STATIC")) {
+  throw new Error(".env.example should document MEM_FRACTION_STATIC");
+}
+
+console.log("sglang starter ok");

package/registry/families/sglang-server/manifest.json

@@ -0,0 +1,182 @@
+{
+  "id": "sglang-server",
+  "description": "SGLang inference engine — RadixAttention prefix caching, constrained/structured generation (JSON schema + regex), fastest-in-class latency on structured outputs. Docker-compose scaffold with sglang.launch_server and an OpenAI-compatible client. For agent products that depend on JSON/tool-call validity and heavy prefix-sharing across requests.",
+  "tags": [
+    "ml",
+    "llm",
+    "inference",
+    "python",
+    "serving",
+    "sglang",
+    "structured-generation"
+  ],
+  "taxonomy": {
+    "language": "python",
+    "runtime": "python",
+    "surface": "inference"
+  },
+  "slots": {
+    "auth": {
+      "options": [
+        "auth:none",
+        "auth:better-auth",
+        "auth:clerk"
+      ],
+      "default": "auth:none"
+    }
+  },
+  "defaults": {
+    "projectType": "inference",
+    "serviceName": "starter-foundry-sglang",
+    "port": 30000,
+    "modelId": "meta-llama/Meta-Llama-3.1-8B-Instruct",
+    "contextLength": 8192
+  },
+  "files": [
+    {
+      "source": "files/docker-compose.yml",
+      "target": "docker-compose.yml"
+    },
+    {
+      "source": "files/requirements.txt",
+      "target": "requirements.txt"
+    },
+    {
+      "source": "files/client.py",
+      "target": "src/client.py"
+    },
+    {
+      "source": "files/launch.sh",
+      "target": "launch.sh"
+    },
+    {
+      "source": "files/.env.example",
+      "target": ".env.example"
+    },
+    {
+      "source": "files/README-sglang.md",
+      "target": "docs/sglang.md"
+    },
+    {
+      "source": "files/validate-sglang.mjs",
+      "target": "validate-sglang.mjs"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "docker-compose.yml"
+    },
+    {
+      "type": "file-exists",
+      "path": "requirements.txt"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/client.py"
+    },
+    {
+      "type": "file-exists",
+      "path": "launch.sh"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-sglang.mjs"
+      ],
+      "expect": "sglang starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "cp .env.example .env",
+      "docker compose up -d",
+      "bash launch.sh",
+      "python -m src.client"
+    ],
+    "entrypoints": [
+      "docker-compose.yml",
+      "launch.sh",
+      "src/client.py"
+    ],
+    "preview": {
+      "path": "/health",
+      "port": "{{port}}"
+    },
+    "extensionPoints": [
+      "docker-compose.yml",
+      "launch.sh",
+      "src/client.py"
+    ]
+  },
+  "keywords": [
+    "sglang",
+    "sglang server",
+    "radix attention",
+    "radixattention",
+    "constrained generation",
+    "structured generation",
+    "json schema decoding",
+    "sglang launch_server",
+    "lmsysorg sglang",
+    "fastest structured output"
+  ],
+  "scoring": {
+    "boost": {
+      "sglang": 4,
+      "radix attention": 4,
+      "structured generation": 3
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "sglang",
+      "radix attention",
+      "sglang server",
+      "constrained generation"
+    ],
+    "tier2": [
+      "structured generation",
+      "json schema decoding",
+      "regex-constrained llm",
+      "sglang launch_server"
+    ],
+    "archetypes": [
+      "structured output llm",
+      "tool-calling inference server",
+      "json-mode inference server"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Pick SGLang when the workload is agentic/tool-calling/JSON-schema-heavy — RadixAttention reuses prefix KV across requests with shared system prompts, and the constrained decoder guarantees valid JSON without re-sampling. For raw throughput on free-form text, vLLM is comparable; for smaller footprints, ollama; for HF ecosystem, tgi.",
+    "firstSteps": [
+      "cp .env.example .env and set MODEL_ID + (optional) HUGGING_FACE_HUB_TOKEN",
+      "docker compose up -d (GPU host) OR `bash launch.sh` (bare-metal Python install)",
+      "curl http://localhost:{{port}}/health",
+      "python -m src.client — exercises plain + JSON-schema-constrained generation"
+    ],
+    "gotchas": [
+      "SGLang ships a torch version pinned inside the Docker image. Don't bind-mount a host Python env — runtime mismatches crash the CUDA kernels.",
+      "RadixAttention's win comes from shared prefixes. If every request has a unique system prompt, SGLang's advantage over vLLM shrinks to nil.",
+      "Constrained generation requires `response_format={'type': 'json_schema', 'schema': {...}}` on the request. Omit that and you get plain unconstrained output.",
+      "Default port is 30000 (not 8000). Make sure LB/firewall rules match.",
+      "--mem-fraction-static above 0.90 can OOM when KV cache grows; 0.85 is the safe default on mixed workloads.",
+      "Gated HF models require HUGGING_FACE_HUB_TOKEN plus license acceptance on the Hub."
+    ],
+    "placeholders": [
+      {
+        "path": "src/main.py",
+        "description": ".env (MODEL_ID, HUGGING_FACE_HUB_TOKEN, CONTEXT_LENGTH)"
+      },
+      {
+        "path": "src/main.py",
+        "description": "launch.sh (model-specific flags, tp-size, mem fraction)"
+      },
+      {
+        "path": "src/main.py",
+        "description": "src/client.py (JSON schema, sampling params)"
+      }
+    ]
+  }
+}