clarifai 11.5.3rc2__py3-none-any.whl → 11.5.5__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.5.3rc2"
+__version__ = "11.5.5"

clarifai/client/model.py

@@ -528,7 +528,10 @@ class Model(Lister, BaseClient):
             inference_params = kwargs.get('inference_params', {})
             output_config = kwargs.get('output_config', {})
             return self.client._predict_by_proto(
-                inputs=inputs, inference_params=inference_params, output_config=output_config
+                inputs=inputs,
+                # method_name="PostModelOutputs",
+                inference_params=inference_params,
+                output_config=output_config,
             )
 
         return self.client.predict(*args, **kwargs)

clarifai/runners/models/model_builder.py

@@ -457,8 +457,8 @@ class ModelBuilder:
         Returns the method signatures for the model class in YAML format.
         """
         model_class = self.load_model_class(mocking=True)
-        method_info = model_class._get_method_info()
-        signatures = {method.name: method.signature for method in method_info.values()}
+        method_infos = model_class._get_method_infos()
+        signatures = {method.name: method.signature for method in method_infos.values()}
         return signatures_to_yaml(signatures)
 
     def get_method_signatures(self, mocking=True):
@@ -472,8 +472,8 @@ class ModelBuilder:
           list: A list of method signatures for the model class.
         """
         model_class = self.load_model_class(mocking=mocking)
-        method_info = model_class._get_method_info()
-        signatures = [method.signature for method in method_info.values()]
+        method_infos = model_class._get_method_infos()
+        signatures = [method.signature for method in method_infos.values()]
         return signatures
 
     @property

clarifai/runners/models/model_class.py

@@ -1,6 +1,5 @@
 import inspect
 import itertools
-import logging
 import os
 import traceback
 from abc import ABC
@@ -20,11 +19,16 @@ from clarifai.runners.utils.method_signatures import (
     serialize,
     signatures_to_json,
 )
+from clarifai.runners.utils.model_utils import is_proto_style_method
+from clarifai.utils.logging import logger
 
 _METHOD_INFO_ATTR = '_cf_method_info'
 
 _RAISE_EXCEPTIONS = os.getenv("RAISE_EXCEPTIONS", "false").lower() in ("true", "1")
 
+FALLBACK_METHOD_PROTO = 'PostModelOutputs'
+FALLBACK_METHOD_PYTHON = 'predict'
+
 
 class ModelClass(ABC):
     '''
@@ -69,8 +73,12 @@ class ModelClass(ABC):
         """Load the model."""
 
     def _handle_get_signatures_request(self) -> service_pb2.MultiOutputResponse:
-        methods = self._get_method_info()
-        signatures = {method.name: method.signature for method in methods.values()}
+        methods = self._get_method_infos()
+        signatures = {
+            method.name: method.signature
+            for method in methods.values()
+            if method.signature is not None
+        }
         resp = service_pb2.MultiOutputResponse(
             status=status_pb2.Status(code=status_code_pb2.SUCCESS)
         )
@@ -99,18 +107,61 @@ class ModelClass(ABC):
         outputs = []
         try:
             # TODO add method name field to proto
-            method_name = 'predict'
+            # to support old callers who might not pass in the method name we have a few defaults.
+            # first we look for a PostModelOutputs method that is implemented as protos and use that
+            # if it exists.
+            # if not we default to 'predict'.
+            method_name = None
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
+            if method_name is None and FALLBACK_METHOD_PROTO in self._get_method_infos():
+                _info = self._get_method_infos(FALLBACK_METHOD_PROTO)
+                if _info.proto_method:
+                    method_name = FALLBACK_METHOD_PROTO
+            if method_name is None:
+                method_name = FALLBACK_METHOD_PYTHON
             if (
                 method_name == '_GET_SIGNATURES'
             ):  # special case to fetch signatures, TODO add endpoint for this
                 return self._handle_get_signatures_request()
-            if method_name not in self._get_method_info():
+            if method_name not in self._get_method_infos():
                 raise ValueError(f"Method {method_name} not found in model class")
             method = getattr(self, method_name)
-            method_info = method._cf_method_info
+            method_info = self._get_method_infos(method_name)
             signature = method_info.signature
+            proto_method = method_info.proto_method
+
+            # If this is an old predict(proto) -> proto method, just call it and return
+            # the response.
+            if proto_method:
+                out_proto = method(request)
+                # if we already have out_proto.status.code set then return
+                if out_proto.status.code != status_code_pb2.ZERO:
+                    return out_proto
+
+                successes = [
+                    out.status.code == status_code_pb2.SUCCESS for out in out_proto.outputs
+                ]
+                if all(successes):
+                    # If all outputs are successful, we can return the response.
+                    out_proto.status.CopyFrom(
+                        status_pb2.Status(code=status_code_pb2.SUCCESS, description='Success')
+                    )
+                    return out_proto
+                if any(successes):
+                    # If some outputs are successful and some are not, we return a mixed status.
+                    out_proto.status.CopyFrom(
+                        status_pb2.Status(
+                            code=status_code_pb2.MIXED_STATUS, description='Mixed Status'
+                        )
+                    )
+                    return out_proto
+                # If all outputs are failures, we return a failure status.
+                out_proto.status.CopyFrom(
+                    status_pb2.Status(code=status_code_pb2.FAILURE, description='Failed')
+                )
+                return out_proto
+
             python_param_types = method_info.python_param_types
             for input in request.inputs:
                 # check if input is in old format
@@ -121,6 +172,7 @@ class ModelClass(ABC):
                         input.data, signature.input_fields
                     )
                     input.data.CopyFrom(new_data)
+
             # convert inputs to python types
             inputs = self._convert_input_protos_to_python(
                 request.inputs, signature.input_fields, python_param_types
@@ -148,7 +200,7 @@ class ModelClass(ABC):
         except Exception as e:
             if _RAISE_EXCEPTIONS:
                 raise
-            logging.exception("Error in predict")
+            logger.exception("Error in predict")
             return service_pb2.MultiOutputResponse(
                 status=status_pb2.Status(
                     code=status_code_pb2.FAILURE,
@@ -165,7 +217,7 @@ class ModelClass(ABC):
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             method = getattr(self, method_name)
-            method_info = method._cf_method_info
+            method_info = self._get_method_infos(method_name)
             signature = method_info.signature
             python_param_types = method_info.python_param_types
             for input in request.inputs:
@@ -207,7 +259,7 @@ class ModelClass(ABC):
         except Exception as e:
             if _RAISE_EXCEPTIONS:
                 raise
-            logging.exception("Error in generate")
+            logger.exception("Error in generate")
             yield service_pb2.MultiOutputResponse(
                 status=status_pb2.Status(
                     code=status_code_pb2.FAILURE,
@@ -227,7 +279,7 @@ class ModelClass(ABC):
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             method = getattr(self, method_name)
-            method_info = method._cf_method_info
+            method_info = self._get_method_infos(method_name)
             signature = method_info.signature
             python_param_types = method_info.python_param_types
 
@@ -282,7 +334,7 @@ class ModelClass(ABC):
         except Exception as e:
             if _RAISE_EXCEPTIONS:
                 raise
-            logging.exception("Error in stream")
+            logger.exception("Error in stream")
             yield service_pb2.MultiOutputResponse(
                 status=status_pb2.Status(
                     code=status_code_pb2.FAILURE,
@@ -359,28 +411,44 @@ class ModelClass(ABC):
                     continue
                 methods[name] = method_info
         # check for generic predict(request) -> response, etc. methods
-        # for name in ('predict', 'generate', 'stream'):
-        #  if hasattr(cls, name):
-        #    method = getattr(cls, name)
-        #    if not hasattr(method, _METHOD_INFO_ATTR):  # not already put in registry
-        #      methods[name] = _MethodInfo(method)
+        # older models never had generate or stream so don't bother with them.
+        for name in [FALLBACK_METHOD_PROTO]:  # , 'GenerateModelOutputs', 'StreamModelOutputs'):
+            if hasattr(cls, name) and name not in methods:
+                method = getattr(cls, name)
+                if not callable(method):
+                    continue
+                if is_proto_style_method(method):
+                    # If this is a proto-style method, we can add it to the registry as a special case.
+                    methods[name] = _MethodInfo(method, proto_method=True)
         # set method table for this class in the registry
         return methods
 
     @classmethod
-    def _get_method_info(cls, func_name=None):
+    def _get_method_infos(cls, func_name=None):
+        # FIXME: this is a re-use of the _METHOD_INFO_ATTR attribute to store the method info
+        # for all methods on the class. Should use a different attribute name to avoid confusion.
         if not hasattr(cls, _METHOD_INFO_ATTR):
             setattr(cls, _METHOD_INFO_ATTR, cls._register_model_methods())
-        method_info = getattr(cls, _METHOD_INFO_ATTR)
+        method_infos = getattr(cls, _METHOD_INFO_ATTR)
         if func_name:
-            return method_info[func_name]
-        return method_info
+            return method_infos[func_name]
+        return method_infos
 
 
 class _MethodInfo:
-    def __init__(self, method):
+    def __init__(self, method, proto_method=False):
+        """Initialize a MethodInfo instance.
+
+        Args:
+            method: The method to wrap.
+            old_method: If True, this is an old proto-style method that returns a proto directly.
+        """
         self.name = method.__name__
-        self.signature = build_function_signature(method)
+        self.proto_method = proto_method
+        if not proto_method:
+            self.signature = build_function_signature(method)
+        else:
+            self.signature = None
         self.python_param_types = {
             p.name: p.annotation
             for p in inspect.signature(method).parameters.values()

clarifai/runners/models/model_runner.py

@@ -5,6 +5,8 @@ from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 from clarifai_protocol import BaseRunner
 from clarifai_protocol.utils.health import HealthProbeRequestHandler
 
+from clarifai.client.auth.helper import ClarifaiAuthHelper
+
 from ..utils.url_fetcher import ensure_urls_downloaded
 from .model_class import ModelClass
 
@@ -42,6 +44,28 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         )
         self.model = model
 
+        # Store authentication parameters for URL fetching
+        self._user_id = user_id
+        self._pat = pat
+        self._token = token
+        self._base_url = base_url
+
+        # Create auth helper if we have sufficient authentication information
+        self._auth_helper = None
+        if self._user_id and (self._pat or self._token):
+            try:
+                self._auth_helper = ClarifaiAuthHelper(
+                    user_id=self._user_id,
+                    app_id="",  # app_id not needed for URL fetching
+                    pat=self._pat or "",
+                    token=self._token or "",
+                    base=self._base_url,
+                    validate=False,  # Don't validate since app_id is empty
+                )
+            except Exception:
+                # If auth helper creation fails, proceed without authentication
+                self._auth_helper = None
+
         # After model load successfully set the health probe to ready and startup
         HealthProbeRequestHandler.is_ready = True
         HealthProbeRequestHandler.is_startup = True
@@ -81,12 +105,22 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         if not runner_item.HasField('post_model_outputs_request'):
             raise Exception("Unexpected work item type: {}".format(runner_item))
         request = runner_item.post_model_outputs_request
-        ensure_urls_downloaded(request)
+        ensure_urls_downloaded(request, auth_helper=self._auth_helper)
 
         resp = self.model.predict_wrapper(request)
-        if resp.status.code != status_code_pb2.SUCCESS:
+        # if we have any non-successful code already it's an error we can return.
+        if (
+            resp.status.code != status_code_pb2.SUCCESS
+            and resp.status.code != status_code_pb2.ZERO
+        ):
             return service_pb2.RunnerItemOutput(multi_output_response=resp)
-        successes = [o.status.code == status_code_pb2.SUCCESS for o in resp.outputs]
+        successes = []
+        for output in resp.outputs:
+            if not output.HasField('status') or not output.status.code:
+                raise Exception(
+                    "Output must have a status code, please check the model implementation."
+                )
+            successes.append(output.status.code == status_code_pb2.SUCCESS)
         if all(successes):
             status = status_pb2.Status(
                 code=status_code_pb2.SUCCESS,
@@ -114,10 +148,14 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         if not runner_item.HasField('post_model_outputs_request'):
             raise Exception("Unexpected work item type: {}".format(runner_item))
         request = runner_item.post_model_outputs_request
-        ensure_urls_downloaded(request)
+        ensure_urls_downloaded(request, auth_helper=self._auth_helper)
 
         for resp in self.model.generate_wrapper(request):
-            if resp.status.code != status_code_pb2.SUCCESS:
+            # if we have any non-successful code already it's an error we can return.
+            if (
+                resp.status.code != status_code_pb2.SUCCESS
+                and resp.status.code != status_code_pb2.ZERO
+            ):
                 yield service_pb2.RunnerItemOutput(multi_output_response=resp)
                 continue
             successes = []
@@ -151,7 +189,11 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
     ) -> Iterator[service_pb2.RunnerItemOutput]:
         # Call the generate() method the underlying model implements.
         for resp in self.model.stream_wrapper(pmo_iterator(runner_item_iterator)):
-            if resp.status.code != status_code_pb2.SUCCESS:
+            # if we have any non-successful code already it's an error we can return.
+            if (
+                resp.status.code != status_code_pb2.SUCCESS
+                and resp.status.code != status_code_pb2.ZERO
+            ):
                 yield service_pb2.RunnerItemOutput(multi_output_response=resp)
                 continue
             successes = []
@@ -181,9 +223,9 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
             yield service_pb2.RunnerItemOutput(multi_output_response=resp)
 
 
-def pmo_iterator(runner_item_iterator):
+def pmo_iterator(runner_item_iterator, auth_helper=None):
     for runner_item in runner_item_iterator:
         if not runner_item.HasField('post_model_outputs_request'):
             raise Exception("Unexpected work item type: {}".format(runner_item))
-        ensure_urls_downloaded(runner_item.post_model_outputs_request)
+        ensure_urls_downloaded(runner_item.post_model_outputs_request, auth_helper=auth_helper)
         yield runner_item.post_model_outputs_request

clarifai/runners/models/model_servicer.py

@@ -5,6 +5,8 @@ from typing import Iterator
 from clarifai_grpc.grpc.api import service_pb2, service_pb2_grpc
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 
+from clarifai.client.auth.helper import ClarifaiAuthHelper
+
 from ..utils.url_fetcher import ensure_urls_downloaded
 
 _RAISE_EXCEPTIONS = os.getenv("RAISE_EXCEPTIONS", "false").lower() in ("true", "1")
@@ -23,6 +25,27 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
         """
         self.model = model
 
+        # Try to create auth helper from environment variables if available
+        self._auth_helper = None
+        try:
+            user_id = os.environ.get("CLARIFAI_USER_ID")
+            pat = os.environ.get("CLARIFAI_PAT")
+            token = os.environ.get("CLARIFAI_SESSION_TOKEN")
+            base_url = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
+
+            if user_id and (pat or token):
+                self._auth_helper = ClarifaiAuthHelper(
+                    user_id=user_id,
+                    app_id="",  # app_id not needed for URL fetching
+                    pat=pat or "",
+                    token=token or "",
+                    base=base_url,
+                    validate=False,  # Don't validate since app_id is empty
+                )
+        except Exception:
+            # If auth helper creation fails, proceed without authentication
+            self._auth_helper = None
+
     def PostModelOutputs(
         self, request: service_pb2.PostModelOutputsRequest, context=None
     ) -> service_pb2.MultiOutputResponse:
@@ -32,7 +55,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
         """
 
         # Download any urls that are not already bytes.
-        ensure_urls_downloaded(request)
+        ensure_urls_downloaded(request, auth_helper=self._auth_helper)
 
         try:
             return self.model.predict_wrapper(request)
@@ -56,7 +79,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
         returns an output.
         """
         # Download any urls that are not already bytes.
-        ensure_urls_downloaded(request)
+        ensure_urls_downloaded(request, auth_helper=self._auth_helper)
 
         try:
             yield from self.model.generate_wrapper(request)
@@ -84,7 +107,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
 
         # Download any urls that are not already bytes.
         for req in request:
-            ensure_urls_downloaded(req)
+            ensure_urls_downloaded(req, auth_helper=self._auth_helper)
 
         try:
             yield from self.model.stream_wrapper(request_copy)

clarifai/runners/utils/code_script.py

@@ -18,7 +18,9 @@ def has_signature_method(
     :param method_signatures: List of MethodSignature objects to search in.
     :return: True if a method with the given name exists, False otherwise.
     """
-    return any(method_signature.name == name for method_signature in method_signatures)
+    return any(
+        method_signature.name == name for method_signature in method_signatures if method_signature
+    )
 
 
 def generate_client_script(
@@ -153,6 +155,8 @@ model = Model("{model_ui_url}",
     # Generate method signatures
     method_signatures_str = []
     for method_signature in method_signatures:
+        if method_signature is None:
+            continue
         method_name = method_signature.name
         client_script_str = f'response = model.{method_name}('
         annotations = _get_annotations_source(method_signature)

clarifai/runners/utils/data_types/data_types.py

@@ -174,13 +174,10 @@ class Text(MessageData):
 
 
 class Concept(MessageData):
-    def __init__(self, name: str, value: float = 1.0, id: str = None,
-                 user_id: str = None, app_id: str = None):
+    def __init__(self, name: str, value: float = 1.0, id: str = None):
         self.name = name
         self.value = value
         self.id = id or Concept._concept_name_to_id(name)
-        self.user_id = user_id
-        self.app_id = app_id
 
     @staticmethod
     def _concept_name_to_id(name: str):
@@ -189,14 +186,14 @@ class Concept(MessageData):
         return _name
 
     def __repr__(self) -> str:
-        return f"Concept(id={self.id!r}, name={self.name!r}, value={self.value!r}, user_id={self.user_id!r}, app_id={self.app_id!r})"
+        return f"Concept(id={self.id!r}, name={self.name!r}, value={self.value})"
 
     def to_proto(self):
-        return ConceptProto(id=self.id, name=self.name, value=self.value, user_id=self.user_id, app_id=self.app_id)
+        return ConceptProto(id=self.id, name=self.name, value=self.value)
 
     @classmethod
     def from_proto(cls, proto: ConceptProto) -> "Concept":
-        return cls(id=proto.id, name=proto.name, value=proto.value, user_id=proto.user_id, app_id=proto.app_id)
+        return cls(id=proto.id, name=proto.name, value=proto.value)
 
 
 class Region(MessageData):
@@ -210,7 +207,6 @@ class Region(MessageData):
         track_id: str = None,
         text: str = None,
         id: str = None,
-        value: float = None,
     ):
         if proto_region is None:
             self.proto = RegionProto()
@@ -227,8 +223,6 @@ class Region(MessageData):
                 self.track_id = track_id
             if text:
                 self.text = text
-            if value:
-                self.value = value
             self.id = id if id is not None else uuid.uuid4().hex
         elif isinstance(proto_region, RegionProto):
             self.proto = proto_region
@@ -328,19 +322,8 @@ class Region(MessageData):
         point_proto = PointProto(col=x, row=y, z=z)
         self.proto.region_info.point.CopyFrom(point_proto)
 
-    @property
-    def value(self) -> float:
-        """Value of the region, typically used for confidence scores."""
-        return self.proto.value
-
-    @value.setter
-    def value(self, value: float):
-        if not isinstance(value, (int, float)):
-            raise TypeError(f"Expected int or float for value, got {type(value).__name__}")
-        self.proto.value = float(value)
-
     def __repr__(self) -> str:
-        return f"Region(id={self.id},box={self.box or []}, concepts={self.concepts or None}, point={self.point or None}, mask={self.mask or None}, track_id={self.track_id or None}, value={self.value or None})"
+        return f"Region(id={self.id},box={self.box or []}, concepts={self.concepts or None}, point={self.point or None}, mask={self.mask or None}, track_id={self.track_id or None})"
 
     def to_proto(self) -> RegionProto:
         return self.proto

clarifai/runners/utils/model_utils.py

@@ -1,3 +1,4 @@
+import inspect
 import os
 import shlex
 import signal
@@ -8,6 +9,7 @@ import time
 
 import psutil
 import requests
+from clarifai_grpc.grpc.api import service_pb2
 
 from clarifai.utils.logging import logger
 
@@ -133,3 +135,50 @@ def wait_for_server(base_url: str, timeout: int = None) -> None:
                 raise TimeoutError("Server did not become ready within timeout period")
         except requests.exceptions.RequestException:
             time.sleep(1)
+
+
+def is_proto_style_method(method):
+    """
+    Determines if the given method is likely an old-style proto method:
+    - Has a 'request' parameter after 'self'
+    - Optionally, returns a known proto response type
+    """
+    try:
+        sig = inspect.signature(method)
+        params = list(sig.parameters.values())
+
+        # Must have at least 'self' and one argument
+        if len(params) < 2:
+            return False
+
+        # First parameter should be 'self'
+        if params[0].name != 'self':
+            return False
+        # Second param typically should be named 'request'
+        request_param = params[1]
+        if request_param.name != 'request':
+            return False
+        # Optionally: check annotation is a proto type
+        # (If signature is incomplete, this part will gracefully fall through)
+        return_annotation = sig.return_annotation
+        # If type annotation is available, check it's PostModelOutputsRequest
+        if (
+            request_param.annotation != inspect.Parameter.empty
+            and request_param.annotation != service_pb2.PostModelOutputsRequest
+        ):
+            return False
+        # If return annotation is available, check it's MultiOutputResponse
+        if (
+            return_annotation != inspect.Signature.empty
+            and return_annotation != service_pb2.MultiOutputResponse
+        ):
+            return False
+        if (
+            request_param.annotation is inspect.Parameter.empty
+            and return_annotation is inspect.Signature.empty
+        ):
+            return True  # signature OK, even if signature is empty
+        return True
+
+    except (ValueError, TypeError):
+        return False

clarifai/runners/utils/url_fetcher.py

@@ -5,43 +5,88 @@ import fsspec
 from clarifai.utils.logging import logger
 
 
-def download_input(input):
-    _download_input_data(input.data)
+def download_input(input, auth_helper=None):
+    _download_input_data(input.data, auth_helper=auth_helper)
     if input.data.parts:
         for i in range(len(input.data.parts)):
-            _download_input_data(input.data.parts[i].data)
+            _download_input_data(input.data.parts[i].data, auth_helper=auth_helper)
 
 
-def _download_input_data(input_data):
+def _download_input_data(input_data, auth_helper=None):
     """
     This function will download any urls that are not already bytes.
+
+    Args:
+        input_data: The input data containing URLs to download
+        auth_helper: Optional ClarifaiAuthHelper instance for authentication
     """
+    # Get auth headers if auth_helper is provided
+    auth_kwargs = {}
+    if auth_helper is not None:
+        auth_kwargs = _get_auth_kwargs(auth_helper)
+
     if input_data.image.url and not input_data.image.base64:
         # Download the image
-        with fsspec.open(input_data.image.url, 'rb') as f:
+        with fsspec.open(input_data.image.url, 'rb', **auth_kwargs) as f:
             input_data.image.base64 = f.read()
     if input_data.video.url and not input_data.video.base64:
         # Download the video
-        with fsspec.open(input_data.video.url, 'rb') as f:
+        with fsspec.open(input_data.video.url, 'rb', **auth_kwargs) as f:
             input_data.video.base64 = f.read()
     if input_data.audio.url and not input_data.audio.base64:
         # Download the audio
-        with fsspec.open(input_data.audio.url, 'rb') as f:
+        with fsspec.open(input_data.audio.url, 'rb', **auth_kwargs) as f:
             input_data.audio.base64 = f.read()
     if input_data.text.url and not input_data.text.raw:
         # Download the text
-        with fsspec.open(input_data.text.url, 'r') as f:
+        with fsspec.open(input_data.text.url, 'r', **auth_kwargs) as f:
             input_data.text.raw = f.read()
 
 
-def ensure_urls_downloaded(request, max_threads=128):
+def _get_auth_kwargs(auth_helper):
+    """
+    Convert ClarifaiAuthHelper metadata to fsspec-compatible kwargs.
+
+    Args:
+        auth_helper: ClarifaiAuthHelper instance
+
+    Returns:
+        dict: kwargs to pass to fsspec.open() for authentication
+    """
+    if auth_helper is None:
+        return {}
+
+    try:
+        # Get authentication metadata from the helper
+        metadata = auth_helper.metadata
+
+        # Convert gRPC metadata tuples to HTTP headers dict
+        headers = {}
+        for key, value in metadata:
+            # Skip non-auth headers
+            if key in ('authorization', 'x-clarifai-session-token'):
+                headers[key] = value
+
+        # Return fsspec-compatible kwargs
+        return {'client_kwargs': {'headers': headers}}
+    except Exception as e:
+        logger.warning(f"Failed to get authentication headers: {e}")
+        return {}
+
+
+def ensure_urls_downloaded(request, max_threads=128, auth_helper=None):
     """
     This function will download any urls that are not already bytes and parallelize with a thread pool.
+
+    Args:
+        request: The request containing inputs with URLs to download
+        max_threads: Maximum number of threads to use for parallel downloads
+        auth_helper: Optional ClarifaiAuthHelper instance for authentication
     """
     with concurrent.futures.ThreadPoolExecutor(max_workers=max_threads) as executor:
         futures = []
         for input in request.inputs:
-            futures.append(executor.submit(download_input, input))
+            futures.append(executor.submit(download_input, input, auth_helper))
         for future in concurrent.futures.as_completed(futures):
             try:
                 future.result()