argo-proxy 3.1.0__tar.gz → 3.1.2__tar.gz

{argo_proxy-3.1.0/src/argo_proxy.egg-info → argo_proxy-3.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argo-proxy
-Version: 3.1.0
+Version: 3.1.2
 Summary: Proxy server to Argo API, OpenAI format compatible
 Author-email: Peng Ding <oaklight@gmx.com>
 License-Expression: MIT

{argo_proxy-3.1.0 → argo_proxy-3.1.2/src/argo_proxy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argo-proxy
-Version: 3.1.0
+Version: 3.1.2
 Summary: Proxy server to Argo API, OpenAI format compatible
 Author-email: Peng Ding <oaklight@gmx.com>
 License-Expression: MIT

{argo_proxy-3.1.0 → argo_proxy-3.1.2}/src/argo_proxy.egg-info/SOURCES.txt

@@ -41,4 +41,5 @@ test/test_function_calling_multiple.py
 test/test_function_calling_single.py
 test/test_leaked_tool_parser.py
 test/test_model_resolution.py
-tests/test_config_migrate.py
+tests/test_config_migrate.py
+tests/test_unix_socket.py

argo_proxy-3.1.2/src/argoproxy/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.1.2"

{argo_proxy-3.1.0 → argo_proxy-3.1.2}/src/argoproxy/app.py

@@ -331,9 +331,10 @@ def create_app():
             context="app",
         )
 
-        # Only register health check, version, and dev proxy routes
+        # Register basic utility routes available in dev mode
         app.router.add_get("/health", health_check)
         app.router.add_get("/version", get_version)
+        app.router.add_post("/refresh", refresh_models)
 
         # Register dev proxy routes using a temporary config for URL resolution
         dev_config = ArgoConfig()
@@ -366,7 +367,7 @@ def create_app():
     return app
 
 
-def run(*, host: str = "0.0.0.0", port: int = 8080):
+def run(*, host: str = "0.0.0.0", port: int = 8080, socket: str = ""):
     app = create_app()
 
     # Add this to ensure signal handlers trigger a full shutdown
@@ -378,7 +379,68 @@ def run(*, host: str = "0.0.0.0", port: int = 8080):
         signal.signal(sig, _force_exit)
 
     try:
-        web.run_app(app, host=host, port=port)
+        if socket:
+            _run_unix_socket(app, socket)
+        else:
+            web.run_app(app, host=host, port=port)
     except Exception as e:
         log_error(f"An error occurred while starting the server: {e}", context="app")
         sys.exit(1)
+
+
+def _run_unix_socket(app: web.Application, socket_path: str):
+    """Start the server listening on a Unix domain socket.
+
+    Removes any stale socket file, starts the app, then restricts
+    permissions to owner-only (0o600) so other users on a shared
+    host cannot connect.
+    """
+    import stat
+
+    path = os.path.realpath(socket_path)
+
+    # Remove stale socket if present
+    if os.path.exists(path):
+        try:
+            st = os.stat(path)
+            if stat.S_ISSOCK(st.st_mode):
+                os.unlink(path)
+                log_info(f"Removed stale socket: {path}", context="app")
+            else:
+                log_error(
+                    f"Socket path exists and is not a socket: {path}", context="app"
+                )
+                sys.exit(1)
+        except OSError as e:
+            log_error(f"Cannot remove stale socket {path}: {e}", context="app")
+            sys.exit(1)
+
+    # Ensure parent directory exists
+    parent = os.path.dirname(path)
+    if not os.path.isdir(parent):
+        log_error(f"Socket parent directory does not exist: {parent}", context="app")
+        sys.exit(1)
+
+    async def _set_socket_permissions(app_inner: web.Application):
+        """Set restrictive permissions on the socket after it is created."""
+        if os.path.exists(path):
+            os.chmod(path, 0o600)
+            log_info(
+                f"Socket permissions set to 0700 (owner-only): {path}",
+                context="app",
+            )
+
+    async def _cleanup_socket(app_inner: web.Application):
+        """Remove socket file on shutdown."""
+        if os.path.exists(path):
+            try:
+                os.unlink(path)
+                log_info(f"Removed socket: {path}", context="app")
+            except OSError:
+                pass
+
+    app.on_startup.append(_set_socket_permissions)
+    app.on_shutdown.append(_cleanup_socket)
+
+    log_info(f"Starting server on unix socket: {path}", context="app")
+    web.run_app(app, path=path)

{argo_proxy-3.1.0 → argo_proxy-3.1.2}/src/argoproxy/cli/handlers.py

@@ -12,7 +12,7 @@ from .._vendor.semver import version_parse
 from ..__init__ import __version__
 from ..config import PATHS_TO_TRY, validate_config
 from ..utils.attack_logger import get_attack_logger
-from ..utils.logging import log_error
+from ..utils.logging import log_error, log_info
 from .display import CHANGELOG_URL, display_startup_banner
 
 
@@ -25,8 +25,12 @@ def set_config_envs(args: argparse.Namespace):
     """Set environment variables from serve CLI arguments."""
     if args.config:
         os.environ["CONFIG_PATH"] = args.config
+    if args.host:
+        os.environ["HOST"] = args.host
     if args.port:
         os.environ["PORT"] = str(args.port)
+    if getattr(args, "socket", None):
+        os.environ["SOCKET"] = args.socket
     if args.verbose:
         os.environ["VERBOSE"] = str(True)
     if args.quiet:
@@ -73,7 +77,22 @@ def handle_serve(args: argparse.Namespace):
         if config_path is not None:
             get_attack_logger().set_config_path(config_path)
 
-        run(host=config_instance.host, port=config_instance.port)
+        if config_instance.socket:
+            log_info(
+                f"🌐 Listening on unix://{config_instance.socket}",
+                context="cli",
+            )
+        else:
+            log_info(
+                f"🌐 Listening on http://{config_instance.host}:{config_instance.port}",
+                context="cli",
+            )
+
+        run(
+            host=config_instance.host,
+            port=config_instance.port,
+            socket=config_instance.socket,
+        )
     except KeyError:
         log_error("Port not specified in configuration file.", context="cli")
         sys.exit(1)

{argo_proxy-3.1.0 → argo_proxy-3.1.2}/src/argoproxy/cli/parser.py

@@ -40,6 +40,17 @@ def _add_serve_arguments(parser: argparse.ArgumentParser) -> None:
         type=int,
         help="Port number to bind the server to",
     )
+    parser.add_argument(
+        "--socket",
+        "-S",
+        type=str,
+        default=None,
+        help=(
+            "Unix socket path to listen on (overrides --host/--port).\n"
+            "Permissions are set to 0700 (owner-only) for security on\n"
+            "shared hosts. Example: /run/user/$(id -u)/argo-proxy.sock"
+        ),
+    )
 
     verbosity = parser.add_mutually_exclusive_group()
     verbosity.add_argument(

{argo_proxy-3.1.0 → argo_proxy-3.1.2}/src/argoproxy/config/io.py

@@ -34,7 +34,15 @@ def _format_config_yaml(data: dict) -> str:
     groups: list[tuple[str, list[str]]] = [
         (
             "# Core settings",
-            ["config_version", "user", "host", "port", "verbose", "log_to_file"],
+            [
+                "config_version",
+                "user",
+                "host",
+                "port",
+                "socket",
+                "verbose",
+                "log_to_file",
+            ],
         ),
         (
             "# Upstream",
@@ -118,6 +126,12 @@ def save_config(
 
 def _apply_env_overrides(config_data: ArgoConfig) -> ArgoConfig:
     """Apply environment variable overrides to the config."""
+    if env_host := os.getenv("HOST"):
+        config_data.host = env_host
+
+    if env_socket := os.getenv("SOCKET"):
+        config_data.socket = env_socket
+
     if env_port := os.getenv("PORT"):
         config_data.port = int(env_port)
 

{argo_proxy-3.1.0 → argo_proxy-3.1.2}/src/argoproxy/config/model.py

@@ -30,6 +30,7 @@ class ArgoConfig:
     # Configuration fields with default values
     host: str = "0.0.0.0"  # Default to 0.0.0.0
     port: int = 44497
+    socket: str = ""  # Unix socket path; overrides host:port when set
     user: str = ""
     verbose: bool = True
 
@@ -72,6 +73,9 @@ class ArgoConfig:
     log_to_file: bool = False  # Enable file logging alongside stdout
     max_log_history: int = 3  # Keep last N messages in verbose request logs
 
+    # Model list auto-refresh
+    model_refresh_interval_hours: float = 24  # 0 to disable
+
     # Image processing settings
     enable_payload_control: bool = False  # Enable automatic payload size control
     max_payload_size: int = 20  # MB default (total for all images)
@@ -245,6 +249,10 @@ class ArgoConfig:
         # Drop private fields
         serialized = {k: v for k, v in serialized.items() if not k.startswith("_")}
 
+        # Only persist socket when explicitly set
+        if not self.socket:
+            serialized.pop("socket", None)
+
         # Add the user-configurable base URL (stored as private field)
         if self._argo_base_url:
             serialized["argo_base_url"] = self.argo_base_url
@@ -259,6 +267,10 @@ class ArgoConfig:
         if self._dump_dir:
             serialized["dump_dir"] = self._dump_dir
 
+        # Persist model refresh interval only when non-default
+        if self.model_refresh_interval_hours == 24:
+            serialized.pop("model_refresh_interval_hours", None)
+
         # Persist native URLs only when explicitly overridden (differ from
         # the values that would be derived from argo_base_url)
         base = self.argo_base_url

{argo_proxy-3.1.0 → argo_proxy-3.1.2}/src/argoproxy/models.py

@@ -30,35 +30,43 @@ def flatten_mapping(mapping: dict[str, Any]) -> dict[str, str]:
     return flat
 
 
-# Default models fallback
+# Default models fallback — kept in sync with the live /v1/models endpoint.
 _DEFAULT_CHAT_MODELS = flatten_mapping(
     {
-        # openai
-        "gpt35": "argo:gpt-3.5-turbo",
-        "gpt35large": "argo:gpt-3.5-turbo-16k",
-        "gpt4": "argo:gpt-4",
-        "gpt4large": "argo:gpt-4-32k",
-        "gpt4turbo": "argo:gpt-4-turbo",
+        # openai – gpt-4o (legacy, still served)
         "gpt4o": "argo:gpt-4o",
-        "gpt4olatest": "argo:gpt-4o-latest",
-        "gpto1mini": ["argo:gpt-o1-mini", "argo:o1-mini"],
-        "gpto3mini": ["argo:gpt-o3-mini", "argo:o3-mini"],
+        # openai – o-series reasoning
         "gpto1": ["argo:gpt-o1", "argo:o1"],
-        "gpto1preview": ["argo:gpt-o1-preview", "argo:o1-preview"],  # about to retire
+        "gpto3mini": ["argo:gpt-o3-mini", "argo:o3-mini"],
         "gpto3": ["argo:gpt-o3", "argo:o3"],
         "gpto4mini": ["argo:gpt-o4-mini", "argo:o4-mini"],
+        # openai – gpt-4.1 family
         "gpt41": "argo:gpt-4.1",
         "gpt41mini": "argo:gpt-4.1-mini",
         "gpt41nano": "argo:gpt-4.1-nano",
+        # openai – gpt-5 family
+        "gpt5": "argo:gpt-5",
+        "gpt5mini": "argo:gpt-5-mini",
+        "gpt5nano": "argo:gpt-5-nano",
+        "gpt51": "argo:gpt-5.1",
+        "gpt52": "argo:gpt-5.2",
+        "gpt54": "argo:gpt-5.4",
+        "gpt55": "argo:gpt-5.5",
         # gemini
         "gemini25pro": "argo:gemini-2.5-pro",
         "gemini25flash": "argo:gemini-2.5-flash",
-        # claude
-        "claudeopus4": ["argo:claude-opus-4", "argo:claude-4-opus"],
-        "claudeopus47": ["argo:claude-opus-4.7", "argo:claude-4.7-opus"],
-        "claudesonnet4": ["argo:claude-sonnet-4", "argo:claude-4-sonnet"],
-        "claudesonnet37": ["argo:claude-sonnet-3.7", "argo:claude-3.7-sonnet"],
-        "claudesonnet35v2": ["argo:claude-sonnet-3.5-v2", "argo:claude-3.5-sonnet-v2"],
+        "gemini35flash": "argo:gemini-3.5-flash",
+        "gemini31flashlite": "argo:gemini-3.1-flash-lite",
+        # claude – opus
+        "claudeopus47": ["argo:claude-4.7-opus", "argo:claude-opus-4.7"],
+        "claudeopus46": ["argo:claude-4.6-opus", "argo:claude-opus-4.6"],
+        "claudeopus45": ["argo:claude-4.5-opus", "argo:claude-opus-4.5"],
+        "claudeopus41": ["argo:claude-4.1-opus", "argo:claude-opus-4.1"],
+        # claude – sonnet
+        "claudesonnet46": ["argo:claude-4.6-sonnet", "argo:claude-sonnet-4.6"],
+        "claudesonnet45": ["argo:claude-4.5-sonnet", "argo:claude-sonnet-4.5"],
+        # claude – haiku
+        "claudehaiku45": ["argo:claude-4.5-haiku", "argo:claude-haiku-4.5"],
     }
 )
 
@@ -84,11 +92,8 @@ def filter_model_by_patterns(
     return sorted(matching)
 
 
-# any models that unable to handle system prompt
-NO_SYS_MSG_PATTERNS: set[str] = {
-    "*o1preview",  # Explicitly matches gpto1preview
-    "*o1mini",  # Explicitly matches gpto1mini
-}
+# any models that unable to handle system prompt (o1-mini / o1-preview retired)
+NO_SYS_MSG_PATTERNS: set[str] = set()
 
 NO_SYS_MSG_MODELS = filter_model_by_patterns(
     _DEFAULT_CHAT_MODELS,
@@ -123,11 +128,12 @@ NATIVE_TOOL_CALL_MODELS = filter_model_by_patterns(
 )
 
 TIKTOKEN_ENCODING_PREFIX_MAPPING = {
+    "gpt5": "o200k_base",  # gpt-5 family
     "gpto": "o200k_base",  # o-series
     "gpt4o": "o200k_base",  # gpt-4o
+    "gpt41": "o200k_base",  # gpt-4.1 family
     # this order need to be preserved to correctly parse mapping
-    "gpt4": "cl100k_base",  # gpt-4 series
-    "gpt3": "cl100k_base",  # gpt-3 series
+    "gpt4": "cl100k_base",  # gpt-4 series (legacy fallback)
     "ada002": "cl100k_base",  # embedding
     "v3": "cl100k_base",  # embedding
 }
@@ -474,7 +480,7 @@ def _categorize_results(
             unavailable.clear()
         else:
             log_error(
-                "Proceeding without unavailable models. Subsequent calls to these models will be replaced with argo:gpt-4o",
+                "Proceeding without unavailable models. Subsequent calls to these models will be replaced with argo:gpt-5-nano",
                 context="models",
             )
 
@@ -550,10 +556,16 @@ class ModelRegistry:
                 f"Initial availability check failed: {str(e)}", context="ModelRegistry"
             )
 
-        # # Start periodic refresh (default 24h)
-        # self._refresh_task = asyncio.create_task(
-        #     self._periodic_refresh(interval_hours=24)
-        # )
+        # Start periodic refresh if configured
+        interval = self._config.model_refresh_interval_hours
+        if interval > 0:
+            self._refresh_task = asyncio.create_task(
+                self._periodic_refresh(interval_hours=interval)
+            )
+            log_info(
+                f"Periodic model refresh enabled: every {interval}h",
+                context="ModelRegistry",
+            )
 
     async def refresh_availability(self, real_test: bool = False):
         """Refresh model availability status"""
@@ -632,14 +644,27 @@ class ModelRegistry:
                     "Falling back to default model list", context="ModelRegistry"
                 )
 
-    # async def _periodic_refresh(self, interval_hours: float):
-    #     """Background task for periodic refresh"""
-    #     while True:
-    #         await asyncio.sleep(interval_hours * 3600)
-    #         try:
-    #             await self.refresh_availability()
-    #         except Exception as e:
-    #             logger.error(f"Periodic refresh failed: {str(e)}")
+    async def _periodic_refresh(self, interval_hours: float):
+        """Background task that refreshes the model list on a fixed interval."""
+        try:
+            while True:
+                await asyncio.sleep(interval_hours * 3600)
+                log_info(
+                    f"Periodic model refresh triggered (every {interval_hours}h)",
+                    context="ModelRegistry",
+                )
+                try:
+                    await self.refresh_availability()
+                except Exception as e:
+                    log_error(
+                        f"Periodic refresh failed: {e!s}",
+                        context="ModelRegistry",
+                    )
+        except asyncio.CancelledError:
+            log_debug(
+                "Periodic model refresh task cancelled",
+                context="ModelRegistry",
+            )
 
     async def manual_refresh(self):
         """Trigger manual refresh of model data"""
@@ -756,9 +781,13 @@ class ModelRegistry:
             return model_name
 
         if model_type == "chat":
-            default_model = "argo:gpt-4o"
+            default_model = "argo:gpt-5-nano"
         elif model_type == "embed":
             default_model = "argo:text-embedding-3-small"
+        log_warning(
+            f"Model '{model_name}' not found in registry, falling back to {default_model}",
+            context="ModelRegistry",
+        )
         return self.available_models[default_model]
 
     def as_openai_list(self) -> dict[str, Any]:

argo_proxy-3.1.2/tests/test_unix_socket.py

@@ -0,0 +1,179 @@
+"""Tests for Unix socket support in argo-proxy.
+
+Covers the config model, CLI parser, IO formatting, and end-to-end
+server lifecycle on a Unix domain socket.
+"""
+
+import asyncio
+import os
+import socket as sock_mod
+import stat
+
+import aiohttp
+import pytest
+from aiohttp import web
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def tmp_sock(tmp_path):
+    """Return a path for a temporary socket (does not create it)."""
+    return str(tmp_path / "argo-proxy-test.sock")
+
+
+# ---------------------------------------------------------------------------
+# Config model tests
+# ---------------------------------------------------------------------------
+
+
+class TestArgoConfigSocket:
+    """ArgoConfig socket field behavior."""
+
+    def test_default_empty(self):
+        from argoproxy.config.model import ArgoConfig
+
+        c = ArgoConfig()
+        assert c.socket == ""
+
+    def test_from_dict(self):
+        from argoproxy.config.model import ArgoConfig
+
+        c = ArgoConfig.from_dict({"socket": "/tmp/x.sock", "user": "t", "port": 9999})
+        assert c.socket == "/tmp/x.sock"
+        assert c.port == 9999
+
+    def test_persistent_dict_omits_when_empty(self):
+        from argoproxy.config.model import ArgoConfig
+
+        d = ArgoConfig().to_persistent_dict()
+        assert "socket" not in d
+
+    def test_persistent_dict_includes_when_set(self):
+        from argoproxy.config.model import ArgoConfig
+
+        c = ArgoConfig(socket="/run/user/1000/argo-proxy.sock")
+        d = c.to_persistent_dict()
+        assert d["socket"] == "/run/user/1000/argo-proxy.sock"
+
+
+# ---------------------------------------------------------------------------
+# Config IO tests
+# ---------------------------------------------------------------------------
+
+
+class TestConfigIO:
+    """YAML formatting and env-override for socket field."""
+
+    def test_yaml_includes_socket_when_set(self):
+        from argoproxy.config.io import _format_config_yaml
+        from argoproxy.config.model import ArgoConfig
+
+        c = ArgoConfig(socket="/tmp/s.sock", user="test")
+        yaml_out = _format_config_yaml(c.to_persistent_dict())
+        assert "socket:" in yaml_out
+
+    def test_yaml_omits_socket_when_empty(self):
+        from argoproxy.config.io import _format_config_yaml
+        from argoproxy.config.model import ArgoConfig
+
+        c = ArgoConfig(user="test")
+        yaml_out = _format_config_yaml(c.to_persistent_dict())
+        assert "socket:" not in yaml_out
+
+    def test_env_override(self, monkeypatch):
+        from argoproxy.config.io import _apply_env_overrides
+        from argoproxy.config.model import ArgoConfig
+
+        monkeypatch.setenv("SOCKET", "/tmp/env.sock")
+        c = _apply_env_overrides(ArgoConfig(user="test"))
+        assert c.socket == "/tmp/env.sock"
+
+
+# ---------------------------------------------------------------------------
+# CLI parser tests
+# ---------------------------------------------------------------------------
+
+
+class TestCLIParser:
+    """--socket / -S flags on the serve subcommand."""
+
+    def test_long_flag(self):
+        from argoproxy.cli.parser import create_parser
+
+        args = create_parser().parse_args(["serve", "--socket", "/tmp/t.sock"])
+        assert args.socket == "/tmp/t.sock"
+
+    def test_short_flag(self):
+        from argoproxy.cli.parser import create_parser
+
+        args = create_parser().parse_args(["serve", "-S", "/tmp/s.sock"])
+        assert args.socket == "/tmp/s.sock"
+
+    def test_default_none(self):
+        from argoproxy.cli.parser import create_parser
+
+        args = create_parser().parse_args(["serve"])
+        assert args.socket is None
+
+
+# ---------------------------------------------------------------------------
+# End-to-end unix socket server test
+# ---------------------------------------------------------------------------
+
+
+class TestUnixSocketServer:
+    """Start aiohttp on a unix socket, verify connectivity and permissions."""
+
+    def test_socket_lifecycle(self, tmp_sock):
+        """Server listens on socket, responds to requests, permissions are 0700."""
+
+        async def _run():
+            async def health(request):
+                return web.json_response({"status": "healthy"})
+
+            app = web.Application()
+            app.router.add_get("/health", health)
+
+            runner = web.AppRunner(app)
+            await runner.setup()
+            site = web.UnixSite(runner, tmp_sock)
+            await site.start()
+
+            # Socket exists and is a socket
+            assert os.path.exists(tmp_sock)
+            assert stat.S_ISSOCK(os.stat(tmp_sock).st_mode)
+
+            # Set permissions like _run_unix_socket does
+            os.chmod(tmp_sock, 0o600)
+            assert os.stat(tmp_sock).st_mode & 0o777 == 0o600
+
+            # Hit the health endpoint
+            conn = aiohttp.UnixConnector(path=tmp_sock)
+            async with aiohttp.ClientSession(connector=conn) as session:
+                async with session.get("http://localhost/health") as resp:
+                    assert resp.status == 200
+                    body = await resp.json()
+                    assert body == {"status": "healthy"}
+
+            await runner.cleanup()
+
+        asyncio.run(_run())
+
+    def test_stale_socket_removal(self, tmp_sock):
+        """A stale socket file is detected and can be removed."""
+        # Create a real socket file (simulate stale)
+        s = sock_mod.socket(sock_mod.AF_UNIX, sock_mod.SOCK_STREAM)
+        s.bind(tmp_sock)
+        s.close()
+
+        assert os.path.exists(tmp_sock)
+        st = os.stat(tmp_sock)
+        assert stat.S_ISSOCK(st.st_mode)
+
+        # Our code removes stale sockets
+        os.unlink(tmp_sock)
+        assert not os.path.exists(tmp_sock)

argo_proxy-3.1.0/src/argoproxy/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.1.0"