Fix/types (#570)

* typesafe

* imports

* typesafe

* refactor bedrock, pyproject

* type safety

* type safety, stream fixes, glm-4.7

* types and tests

* lint

* type safety, streaming fix

* type saftey

* type checks

* add ty to ci

* typecheck

* add ty, typecheck, diff for toad

* fix typecheck script

* updates to streaming, diff, default model for gpt-oss-120b

* text changes

* ty lockfile

* diffs, types

Author: evalstate

.github/workflows/checks.yml

@@ -48,6 +48,9 @@ jobs:
       - name: Run pyright
         run: uv run scripts/lint.py
 
+      - name: Run ty
+        run: uv run scripts/typecheck.py
+
   test:
     runs-on: ubuntu-latest
     steps:

.pre-commit-config.yaml

@@ -8,3 +8,10 @@ repos:
         args: [--fix]
       # Run the formatter.
       - id: ruff-format
+  - repo: local
+    hooks:
+      - id: ty
+        name: ty check
+        entry: uv run scripts/typecheck.py
+        language: system
+        pass_filenames: false

examples/tool-use-agent/agent.py

@@ -26,7 +26,9 @@ def __init__(
 @fast.custom(CustomToolAgent)
 async def main() -> None:
     async with fast.run() as agent:
-        await agent.default.generate("What is the topic of the video call no.1234?")
+        await agent.default.generate(
+            "What is the topic of the video call no.1234?",
+        )
 
 
 if __name__ == "__main__":

publish/hf-inference-acp/src/hf_inference_acp/agents.py

@@ -64,44 +64,49 @@ def _normalize_hf_model(model: str) -> str:
     return model
 
 
-async def _lookup_and_format_providers(model: str) -> str | None:
-    """Look up inference providers for a model and return a formatted message.
+def _resolve_alias_display(model: str) -> tuple[str, str] | None:
+    """Resolve alias to full model string for display, preserving suffix overrides."""
+    from fast_agent.llm.model_factory import ModelFactory
 
-    Returns None if the model is not a HuggingFace model (no '/').
-    """
-    import random
+    if not model:
+        return None
 
-    # Extract the HF model ID from various formats
-    model_id = model
+    alias_key = model
+    alias_suffix: str | None = None
+    if ":" in model:
+        alias_key, alias_suffix = model.rsplit(":", 1)
 
-    # Strip hf. prefix if present
-    if model_id.startswith("hf."):
-        model_id = model_id[3:]
+    alias_target = ModelFactory.MODEL_ALIASES.get(alias_key)
+    if not alias_target:
+        return None
 
-    # Strip :provider suffix if present
-    if ":" in model_id:
-        model_id = model_id.rsplit(":", 1)[0]
+    resolved = alias_target
+    if alias_suffix:
+        if ":" in resolved:
+            resolved = resolved.rsplit(":", 1)[0]
+        resolved = f"{resolved}:{alias_suffix}"
 
-    # Must have org/model format
-    if "/" not in model_id:
-        return None
+    return model, resolved
 
-    from fast_agent.llm.hf_inference_lookup import lookup_inference_providers
+
+async def _lookup_and_format_providers(model: str) -> str | None:
+    """Look up inference providers for a model and return a formatted message.
+
+    Returns None if the model is not a HuggingFace model (no '/').
+    """
+    from fast_agent.llm.hf_inference_lookup import (
+        format_provider_help_message,
+        lookup_inference_providers,
+        normalize_hf_model_id,
+    )
+
+    model_id = normalize_hf_model_id(model)
+    if model_id is None:
+        return None
 
     try:
         result = await lookup_inference_providers(model_id)
-        if result.has_providers:
-            providers = result.format_provider_list()
-            model_strings = result.format_model_strings()
-            example = random.choice(model_strings)
-            return (
-                f"**Available providers:** {providers}\n\n"
-                f"**Autoroutes if no provider specified. Example use:** `/set-model {example}`"
-            )
-        elif result.exists:
-            return "No inference providers currently available for this model."
-        else:
-            return None
+        return format_provider_help_message(result)
     except Exception:
         return None
 
@@ -131,8 +136,9 @@ async def attach_llm(self, llm_factory, model=None, request_params=None, **kwarg
         llm = await super().attach_llm(llm_factory, model, request_params, **kwargs)
 
         # Set up wizard callback if LLM supports it
-        if hasattr(llm, "set_completion_callback"):
-            llm.set_completion_callback(self._on_wizard_complete)
+        callback_setter = getattr(llm, "set_completion_callback", None)
+        if callback_setter is not None:
+            callback_setter(self._on_wizard_complete)
 
         return llm
 
@@ -220,32 +226,45 @@ def acp_session_commands_allowlist(self) -> set[str]:
 
     async def _handle_set_model(self, arguments: str) -> str:
         """Handler for /set-model command."""
+        from fast_agent.llm.hf_inference_lookup import validate_hf_model
         from fast_agent.llm.model_factory import ModelFactory
 
-        model = arguments.strip()
+        raw_model = arguments.strip()
+        model = raw_model
         if not model:
             return format_model_list_help()
 
+        alias_info = _resolve_alias_display(raw_model)
+
         # Normalize the model string (auto-add hf. prefix if needed)
         model = _normalize_hf_model(model)
 
-        # Validate the model string before saving to config
+        # Validate the model string format
         try:
             ModelFactory.parse_model_string(model)
         except Exception as e:
             return f"Error: Invalid model `{model}` - {e}"
 
-        # Look up inference providers for this model
-        provider_info = await _lookup_and_format_providers(model)
+        # Validate model exists on HuggingFace and has providers
+        validation = await validate_hf_model(model, aliases=ModelFactory.MODEL_ALIASES)
+        if not validation.valid:
+            return validation.error or "Error: Model validation failed"
 
         try:
             update_model_in_config(model)
             applied = await self._apply_model_to_running_hf_agent(model)
             applied_note = "\n\nApplied to the running Hugging Face agent." if applied else ""
-            provider_prefix = f"{provider_info}\n\n" if provider_info else ""
+            provider_prefix = (
+                f"{validation.display_message}\n\n" if validation.display_message else ""
+            )
+            if alias_info:
+                alias_display, resolved_alias = alias_info
+                model_status = f"Active model set to: `{alias_display}` (`{resolved_alias}`)"
+            else:
+                model_status = f"Default model set to: `{model}`"
             return (
                 f"{provider_prefix}"
-                f"Default model set to: `{model}`\n\nConfig file updated: `{CONFIG_FILE}`"
+                f"{model_status}\n\nConfig file updated: `{CONFIG_FILE}`"
                 f"{applied_note}"
             )
         except Exception as e:
@@ -311,32 +330,19 @@ async def _get_model_provider_info(self, model: str) -> str | None:
 
         Returns None if providers cannot be looked up or model is not a HF model.
         """
-        from fast_agent.llm.hf_inference_lookup import lookup_inference_providers
-
-        # Extract the HF model ID from various formats
-        model_id = model
-
-        # Strip hf. prefix if present
-        if model_id.startswith("hf."):
-            model_id = model_id[3:]
-
-        # Strip :provider suffix if present
-        if ":" in model_id:
-            model_id = model_id.rsplit(":", 1)[0]
+        from fast_agent.llm.hf_inference_lookup import (
+            format_provider_summary,
+            lookup_inference_providers,
+            normalize_hf_model_id,
+        )
 
-        # Must have org/model format
-        if "/" not in model_id:
+        model_id = normalize_hf_model_id(model)
+        if model_id is None:
             return None
 
         try:
             result = await lookup_inference_providers(model_id)
-            if result.has_providers:
-                providers = result.format_provider_list()
-                return f"Available providers: {providers}"
-            elif result.exists:
-                return "No inference providers available"
-            else:
-                return None
+            return format_provider_summary(result)
         except Exception:
             return None
 
@@ -498,29 +504,25 @@ async def _send_connect_update(
             await _send_connect_update(title="Connected", status="in_progress")
 
             # Rebuild system prompt to include fresh server instructions
-            await _send_connect_update(
-                title="Rebuilding system prompt…", status="in_progress"
-            )
-            await self.rebuild_instruction_templates()
+            await _send_connect_update(title="Rebuilding system prompt…", status="in_progress")
+            await self._apply_instruction_templates()
 
             # Get available tools
             await _send_connect_update(title="Fetching available tools…", status="in_progress")
             tools_result = await self._aggregator.list_tools()
             tool_names = [t.name for t in tools_result.tools] if tools_result.tools else []
 
+            # Send final progress update (but don't mark as completed yet -
+            # the return value serves as the completion signal)
             if tool_names:
-                preview = ", ".join(tool_names[:10])
-                suffix = f" (+{len(tool_names) - 10} more)" if len(tool_names) > 10 else ""
                 await _send_connect_update(
-                    title="Connected (tools available)",
+                    title=f"Connected ({len(tool_names)} tools)",
                     status="completed",
-                    message=f"Available tools: {preview}{suffix}",
                 )
             else:
                 await _send_connect_update(
-                    title="Connected (no tools found)",
+                    title="Connected (no tools)",
                     status="completed",
-                    message="No tools available from the server.",
                 )
 
             if tool_names:
@@ -543,30 +545,43 @@ async def _send_connect_update(
 
     async def _handle_set_model(self, arguments: str) -> str:
         """Handler for /set-model in Hugging Face mode."""
+        from fast_agent.llm.hf_inference_lookup import validate_hf_model
         from fast_agent.llm.model_factory import ModelFactory
 
-        model = arguments.strip()
+        raw_model = arguments.strip()
+        model = raw_model
         if not model:
             return format_model_list_help()
 
+        alias_info = _resolve_alias_display(raw_model)
+
         # Normalize the model string (auto-add hf. prefix if needed)
         model = _normalize_hf_model(model)
 
-        # Validate the model string before applying
+        # Validate the model string format
         try:
             ModelFactory.parse_model_string(model)
         except Exception as e:
             return f"Error: Invalid model `{model}` - {e}"
 
-        # Look up inference providers for this model
-        provider_info = await _lookup_and_format_providers(model)
+        # Validate model exists on HuggingFace and has providers
+        validation = await validate_hf_model(model, aliases=ModelFactory.MODEL_ALIASES)
+        if not validation.valid:
+            return validation.error or "Error: Model validation failed"
 
         try:
             # Apply model first - if this fails, don't update config
             await self.apply_model(model)
             update_model_in_config(model)
-            provider_prefix = f"{provider_info}\n\n" if provider_info else ""
-            return f"{provider_prefix}Active model set to: `{model}`\n\nConfig file updated: `{CONFIG_FILE}`"
+            provider_prefix = (
+                f"{validation.display_message}\n\n" if validation.display_message else ""
+            )
+            if alias_info:
+                alias_display, resolved_alias = alias_info
+                model_status = f"Active model set to: `{alias_display}` (`{resolved_alias}`)"
+            else:
+                model_status = f"Active model set to: `{model}`"
+            return f"{provider_prefix}{model_status}\n\nConfig file updated: `{CONFIG_FILE}`"
         except Exception as e:
             return f"Error setting model: {e}"
 

publish/hf-inference-acp/src/hf_inference_acp/cli.py

@@ -11,6 +11,7 @@
 import shlex
 import sys
 from pathlib import Path  # noqa: TC003 - typer needs runtime access
+from typing import Any, cast
 
 import typer
 
@@ -220,7 +221,7 @@ async def run_agents(
     if skills_directory is not None:
         fast_kwargs["skills_directory"] = skills_directory
 
-    fast = FastAgent(**fast_kwargs)
+    fast = FastAgent(**cast("Any", fast_kwargs))
 
     if shell_runtime:
         await fast.app.initialize()

publish/hf-inference-acp/src/hf_inference_acp/hf_config.py

@@ -54,7 +54,7 @@ def discover_hf_token(*, ignore_env: bool = False) -> tuple[str | None, str | No
         from huggingface_hub import get_token
 
         token = get_token()
-        return token, "huggingface_hub" if token else (None, None)
+        return (token, "huggingface_hub") if token else (None, None)
     except ImportError:
         pass
 

publish/hf-inference-acp/src/hf_inference_acp/wizard/model_catalog.py

@@ -40,8 +40,8 @@ def _get_model_string(alias: str) -> str:
     ),
     CuratedModel(
         id="glm",
-        display_name="GLM 4.6",
-        description="ZAI GLM-4.6: Advanced Agentic, Reasoning and Coding Capabilities",
+        display_name="GLM 4.7",
+        description="ZAI GLM-4.7: Superior Agentic, Reasoning and Coding Capabilities",
     ),
     CuratedModel(
         id="minimax",

publish/hf-inference-acp/src/hf_inference_acp/wizard/wizard_llm.py

@@ -414,6 +414,8 @@ async def _handle_confirm(self, user_input: str) -> str:
         elif cmd in ("y", "yes", "confirm", "ok", "save"):
             # Save configuration
             try:
+                if self._state.selected_model is None:
+                    return "No model selected. Please select a model first."
                 update_model_in_config(self._state.selected_model)
                 update_mcp_server_load_on_start("huggingface", self._state.mcp_load_on_start)
                 self._state.stage = WizardStage.COMPLETE

pyproject.toml

@@ -64,16 +64,6 @@ all-providers = [
     "boto3>=1.35.0",
     "tensorzero>=2025.7.5"
 ]
-dev = [
-    "pre-commit>=4.0.1",
-    "pydantic>=2.10.4",
-    "pyyaml>=6.0.2",
-    "ruff>=0.8.4",
-    "pytest>=7.4.0",
-    "pytest-asyncio>=0.21.1",
-    "pytest-cov",
-    "ruamel.yaml>=0.18.0",
-]
 
 [build-system]
 requires = ["hatchling"]
@@ -117,11 +107,13 @@ testpaths = ["tests"]
 
 [dependency-groups]
 dev = [
+    "boto3>=1.35.0",
     "pre-commit>=4.0.1",
     "pydantic>=2.10.4",
     "ruamel.yaml>=0.18.0",
     "pyyaml>=6.0.2",
     "ruff>=0.8.4",
+    "ty>=0.0.5",
     "pytest>=7.4.0",
     "pytest-asyncio>=0.21.1",
     "pytest-cov>=6.1.1",