adds repoid only based on repo name, adds version-robust sfttrainer

launch.sh

@@ -831,8 +831,11 @@ get_input "Experiment name" "smollm3_finetune_$(date +%Y%m%d_%H%M%S)" EXPERIMENT
 
 # Configure model repository name (customizable)
 print_info "Setting up model repository name..."
-DEFAULT_REPO_NAME="$HF_USERNAME/smolfactory-$(date +%Y%m%d)"
-get_input "Model repository name (Hugging Face format: username/repo)" "$DEFAULT_REPO_NAME" REPO_NAME
+# Ask only for short repo name; we'll prefix with username automatically
+DEFAULT_SHORT_REPO="smolfactory-$(date +%Y%m%d)"
+get_input "Model repository name (repo only, no username/)" "$DEFAULT_SHORT_REPO" REPO_SHORT
+# Build full repo id using detected username
+REPO_NAME="$HF_USERNAME/$REPO_SHORT"
 print_status "Model repository: $REPO_NAME"
 
 # Automatically create dataset repository
@@ -1311,10 +1314,10 @@ export HF_USERNAME="$HF_USERNAME"
         --hf-username "$HF_USERNAME" \
         --model-id "$DEMO_MODEL_ID" \
         --subfolder "$DEMO_SUBFOLDER" \
-        --space-name "${REPO_NAME}-demo"
+        --space-name "${REPO_SHORT}-demo"
     
     if [ $? -eq 0 ]; then
-        DEMO_SPACE_URL="https://huggingface.co/spaces/$HF_USERNAME/${REPO_NAME}-demo"
+        DEMO_SPACE_URL="https://huggingface.co/spaces/$HF_USERNAME/${REPO_SHORT}-demo"
         print_status "✅ Demo space deployed successfully: $DEMO_SPACE_URL"
     else
         print_warning "⚠️ Demo space deployment failed, but continuing with pipeline"
@@ -1385,7 +1388,7 @@ echo "📈 Trackio: $TRACKIO_URL"
 echo "📋 Experiment: $EXPERIMENT_NAME"
 echo "📊 Dataset: https://huggingface.co/datasets/$TRACKIO_DATASET_REPO"
 $(if [ "$DEPLOY_DEMO" = "y" ] || [ "$DEPLOY_DEMO" = "Y" ]; then
-echo "🎮 Demo: https://huggingface.co/spaces/$HF_USERNAME/${REPO_NAME}-demo"
+echo "🎮 Demo: https://huggingface.co/spaces/$HF_USERNAME/${REPO_SHORT}-demo"
 fi)
 echo ""
 echo "📋 Summary report saved to: training_summary.md"

scripts/deploy_demo_space.py

@@ -42,9 +42,10 @@ class DemoSpaceDeployer:
                  demo_type: Optional[str] = None):
         self.hf_token = hf_token
         self.hf_username = hf_username
-        self.model_id = model_id
+        # Allow passing just a repo name without username and auto-prefix
+        self.model_id = model_id if "/" in model_id else f"{hf_username}/{model_id}"
         self.subfolder = subfolder
-        self.space_name = space_name or f"{model_id.split('/')[-1]}-demo"
+        self.space_name = space_name or f"{self.model_id.split('/')[-1]}-demo"
         self.space_id = f"{hf_username}/{self.space_name}"
         self.space_url = f"https://huggingface.co/spaces/{self.space_id}"
         

scripts/model_tonic/push_gpt_oss_to_huggingface.py

@@ -247,12 +247,35 @@ This model is licensed under the MIT License.
     
     return card_content
 
+def _resolve_repo_id(repo_name: str, hf_token: str) -> str:
+    """Resolve to username/repo if only repo name was provided."""
+    try:
+        if "/" in repo_name:
+            return repo_name
+        from huggingface_hub import HfApi
+        username = None
+        if hf_token:
+            try:
+                api = HfApi(token=hf_token)
+                info = api.whoami()
+                username = info.get("name") or info.get("username")
+            except Exception:
+                username = None
+        if not username:
+            username = os.getenv("HF_USERNAME")
+        if not username:
+            raise ValueError("Could not determine HF username. Set HF_USERNAME or pass username/repo.")
+        return f"{username}/{repo_name}"
+    except Exception:
+        return repo_name
+
 def push_gpt_oss_model(checkpoint_path, repo_name, hf_token, trackio_url, experiment_name, dataset_repo, author_name, model_description, training_config_type=None, model_name=None, dataset_name=None, batch_size=None, learning_rate=None, max_epochs=None, max_seq_length=None, trainer_type=None):
     """Push GPT-OSS model to Hugging Face Hub"""
     
     print("=== GPT-OSS Model Push Pipeline ===")
     print(f"Checkpoint: {checkpoint_path}")
-    print(f"Repository: {repo_name}")
+    full_repo_id = _resolve_repo_id(repo_name, hf_token)
+    print(f"Repository: {full_repo_id}")
     print(f"Experiment: {experiment_name}")
     print(f"Author: {author_name}")
     
@@ -276,7 +299,7 @@ def push_gpt_oss_model(checkpoint_path, repo_name, hf_token, trackio_url, experi
         # Create model card
         print("Creating model card...")
         model_card_content = create_gpt_oss_model_card(
-            model_name=repo_name,
+            model_name=full_repo_id,
             experiment_name=experiment_name,
             trackio_url=trackio_url,
             dataset_repo=dataset_repo,
@@ -297,18 +320,18 @@ def push_gpt_oss_model(checkpoint_path, repo_name, hf_token, trackio_url, experi
             f.write(model_card_content)
         
         # Push to Hugging Face Hub
-        print(f"Pushing model to: {repo_name}")
+        print(f"Pushing model to: {full_repo_id}")
         
         # Set HF token
         os.environ["HUGGING_FACE_HUB_TOKEN"] = hf_token
         
         # Push using transformers
         from huggingface_hub import HfApi
-        api = HfApi()
+        api = HfApi(token=hf_token)
         
         # Create repository if it doesn't exist
         try:
-            api.create_repo(repo_name, private=False, exist_ok=True)
+            api.create_repo(full_repo_id, private=False, exist_ok=True)
         except Exception as e:
             print(f"Warning: Could not create repository: {e}")
         
@@ -316,12 +339,12 @@ def push_gpt_oss_model(checkpoint_path, repo_name, hf_token, trackio_url, experi
         print("Uploading model files...")
         api.upload_folder(
             folder_path=temp_output,
-            repo_id=repo_name,
+            repo_id=full_repo_id,
             repo_type="model"
         )
         
         print("✅ GPT-OSS model pushed successfully!")
-        print(f"Model URL: https://huggingface.co/{repo_name}")
+        print(f"Model URL: https://huggingface.co/{full_repo_id}")
         
         # Clean up
         import shutil

scripts/model_tonic/push_to_huggingface.py

@@ -73,6 +73,7 @@ class HuggingFacePusher:
         trainer_type: Optional[str] = None
     ):
         self.model_path = Path(model_path)
+        # Original user input (may be just the repo name without username)
         self.repo_name = repo_name
         self.token = token or hf_token or os.getenv('HF_TOKEN')
         self.private = private
@@ -101,6 +102,9 @@ class HuggingFacePusher:
         else:
             raise ImportError("huggingface_hub is required. Install with: pip install huggingface_hub")
         
+        # Resolve the full repo id (username/repo) if user only provided repo name
+        self.repo_id = self._resolve_repo_id(self.repo_name)
+
         # Initialize monitoring if available
         self.monitor = None
         if MONITORING_AVAILABLE:
@@ -112,25 +116,60 @@ class HuggingFacePusher:
                 dataset_repo=self.dataset_repo
             )
         
-        logger.info(f"Initialized HuggingFacePusher for {repo_name}")
+        logger.info(f"Initialized HuggingFacePusher for {self.repo_id}")
         logger.info(f"Dataset repository: {self.dataset_repo}")
+
+    def _resolve_repo_id(self, repo_name: str) -> str:
+        """Return a fully-qualified repo id in the form username/repo.
+
+        If the provided name already contains a '/', it is returned unchanged.
+        Otherwise, we attempt to derive the username from the authenticated token
+        or from the HF_USERNAME environment variable.
+        """
+        try:
+            if "/" in repo_name:
+                return repo_name
+
+            # Need a username. Prefer API whoami(), fallback to env HF_USERNAME
+            username: Optional[str] = None
+            if self.token:
+                try:
+                    user_info = self.api.whoami()
+                    username = user_info.get("name") or user_info.get("username")
+                except Exception:
+                    username = None
+
+            if not username:
+                username = os.getenv("HF_USERNAME")
+
+            if not username:
+                raise ValueError(
+                    "Username could not be determined. Provide a token or set HF_USERNAME, "
+                    "or pass a fully-qualified repo id 'username/repo'."
+                )
+
+            return f"{username}/{repo_name}"
+        except Exception as resolve_error:
+            logger.error(f"Failed to resolve full repo id for '{repo_name}': {resolve_error}")
+            # Fall back to provided value (may fail later at create/upload)
+            return repo_name
     
     def create_repository(self) -> bool:
         """Create the Hugging Face repository"""
         try:
-            logger.info(f"Creating repository: {self.repo_name}")
+            logger.info(f"Creating repository: {self.repo_id}")
             
             # Create repository with timeout handling
             try:
                 # Create repository
                 create_repo(
-                    repo_id=self.repo_name,
+                    repo_id=self.repo_id,
                     token=self.token,
                     private=self.private,
                     exist_ok=True
                 )
                 
-                logger.info(f"✅ Repository created: https://huggingface.co/{self.repo_name}")
+                logger.info(f"✅ Repository created: https://huggingface.co/{self.repo_id}")
                 return True
                 
             except Exception as e:
@@ -189,8 +228,8 @@ class HuggingFacePusher:
             
             # Update with actual values
             variables.update({
-                "repo_name": self.repo_name,
-                "model_name": self.repo_name.split('/')[-1],
+                "repo_name": self.repo_id,
+                "model_name": self.repo_id.split('/')[-1],
                 "experiment_name": self.experiment_name or "model_push",
                 "dataset_repo": self.dataset_repo,
                 "author_name": self.author_name or "Model Author",
@@ -238,7 +277,7 @@ pipeline_tag: text-generation
 base_model: HuggingFaceTB/SmolLM3-3B
 ---
 
-# {self.repo_name.split('/')[-1]}
+# {self.repo_id.split('/')[-1]}
 
 This is a fine-tuned SmolLM3 model based on the HuggingFaceTB/SmolLM3-3B architecture.
 
@@ -269,8 +308,8 @@ This is a fine-tuned SmolLM3 model based on the HuggingFaceTB/SmolLM3-3B archite
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # Load model and tokenizer
-model = AutoModelForCausalLM.from_pretrained("{self.repo_name}")
-tokenizer = AutoTokenizer.from_pretrained("{self.repo_name}")
+model = AutoModelForCausalLM.from_pretrained("{self.repo_id}")
+tokenizer = AutoTokenizer.from_pretrained("{self.repo_id}")
 
 # Generate text
 inputs = tokenizer("Hello, how are you?", return_tensors="pt")
@@ -346,7 +385,7 @@ This model is licensed under the Apache 2.0 License.
                         upload_file(
                             path_or_fileobj=str(file_path),
                             path_in_repo=remote_path,
-                            repo_id=self.repo_name,
+                            repo_id=self.repo_id,
                             token=self.token
                         )
                         logger.info(f"✅ Uploaded {relative_path}")
@@ -381,7 +420,7 @@ This model is licensed under the Apache 2.0 License.
                     upload_file(
                         path_or_fileobj=str(file_path),
                         path_in_repo=f"training_results/{file_name}",
-                        repo_id=self.repo_name,
+                        repo_id=self.repo_id,
                         token=self.token
                     )
             
@@ -397,7 +436,7 @@ This model is licensed under the Apache 2.0 License.
         try:
             logger.info("Creating README.md...")
             
-            readme_content = f"""# {self.repo_name.split('/')[-1]}
+            readme_content = f"""# {self.repo_id.split('/')[-1]}
 
 A fine-tuned SmolLM3 model for text generation tasks.
 
@@ -406,8 +445,8 @@ A fine-tuned SmolLM3 model for text generation tasks.
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
-model = AutoModelForCausalLM.from_pretrained("{self.repo_name}")
-tokenizer = AutoTokenizer.from_pretrained("{self.repo_name}")
+model = AutoModelForCausalLM.from_pretrained("{self.repo_id}")
+tokenizer = AutoTokenizer.from_pretrained("{self.repo_id}")
 
 # Generate text
 text = "Hello, how are you?"
@@ -463,7 +502,7 @@ MIT License
                 path_or_fileobj=str(readme_path),
                 path_in_repo="README.md",
                 token=self.token,
-                repo_id=self.repo_name
+                repo_id=self.repo_id
             )
             
             # Clean up
@@ -483,7 +522,7 @@ MIT License
                 # Log to Trackio
                 self.monitor.log_metrics({
                     "push_action": action,
-                    "repo_name": self.repo_name,
+                    "repo_name": self.repo_id,
                     "model_size_gb": self._get_model_size(),
                     "dataset_repo": self.dataset_repo,
                     **details
@@ -492,7 +531,7 @@ MIT License
                 # Log training summary
                 self.monitor.log_training_summary({
                     "model_push": True,
-                    "model_repo": self.repo_name,
+                    "model_repo": self.repo_id,
                     "dataset_repo": self.dataset_repo,
                     "push_date": datetime.now().isoformat(),
                     **details
@@ -505,7 +544,7 @@ MIT License
     def push_model(self, training_config: Optional[Dict[str, Any]] = None, 
                    results: Optional[Dict[str, Any]] = None) -> bool:
         """Complete model push process with HF Datasets integration"""
-        logger.info(f"🚀 Starting model push to {self.repo_name}")
+        logger.info(f"🚀 Starting model push to {self.repo_id}")
         logger.info(f"📊 Dataset repository: {self.dataset_repo}")
         
         # Validate model path
@@ -533,7 +572,7 @@ MIT License
             upload_file(
                 path_or_fileobj=str(model_card_path),
                 path_in_repo="README.md",
-                repo_id=self.repo_name,
+                repo_id=self.repo_id,
                 token=self.token
             )
         finally:
@@ -556,7 +595,7 @@ MIT License
             "results": results
         })
         
-        logger.info(f"🎉 Model successfully pushed to: https://huggingface.co/{self.repo_name}")
+        logger.info(f"🎉 Model successfully pushed to: https://huggingface.co/{self.repo_id}")
         logger.info(f"📊 Experiment data stored in: {self.dataset_repo}")
         return True
     
@@ -582,7 +621,7 @@ def parse_args():
     
     # Required arguments
     parser.add_argument('model_path', type=str, help='Path to trained model directory')
-    parser.add_argument('repo_name', type=str, help='Hugging Face repository name (username/repo-name)')
+    parser.add_argument('repo_name', type=str, help='Hugging Face repository name (repo-name). Username will be auto-detected from your token.')
     
     # Optional arguments
     parser.add_argument('--token', type=str, default=None, help='Hugging Face token')

scripts/training/train_gpt_oss.py

@@ -537,16 +537,38 @@ def train_gpt_oss(config_path, experiment_name, output_dir, trackio_url, trainer
     # Create SFT configuration
     sft_config = create_sft_config(config, output_dir)
     
-    # Create trainer
+    # Create trainer with version-robust kwargs
     print("Creating SFT trainer...")
-    trainer = SFTTrainer(
-        model=peft_model,
-        args=sft_config,
-        train_dataset=dataset,
-        tokenizer=tokenizer,
-        dataset_text_field="text",
-        max_seq_length=getattr(config, 'max_seq_length', 2048),
-    )
+    try:
+        sft_sig = inspect.signature(SFTTrainer.__init__)
+        sft_params = set(sft_sig.parameters.keys())
+    except Exception:
+        sft_params = {"model", "args", "train_dataset", "tokenizer", "dataset_text_field", "max_seq_length"}
+
+    sft_kwargs = {
+        "model": peft_model,
+        "args": sft_config,
+        "train_dataset": dataset,
+    }
+
+    # Prefer passing tokenizer if supported; otherwise try processing_class
+    if "tokenizer" in sft_params:
+        sft_kwargs["tokenizer"] = tokenizer
+    elif "processing_class" in sft_params:
+        sft_kwargs["processing_class"] = tokenizer
+
+    # Pass dataset text field if supported (we produced a 'text' column)
+    if "dataset_text_field" in sft_params:
+        sft_kwargs["dataset_text_field"] = "text"
+
+    # Pass max sequence length if supported
+    if "max_seq_length" in sft_params:
+        sft_kwargs["max_seq_length"] = getattr(config, 'max_seq_length', 2048)
+
+    # Remove any None values
+    sft_kwargs = {k: v for k, v in sft_kwargs.items() if v is not None}
+
+    trainer = SFTTrainer(**sft_kwargs)
     
     # Start training
     print("Starting GPT-OSS training...")