feat: add auto-generated CI documentation pre-commit hook (#2890)

Our CI is entirely undocumented, this commit adds a README.md file with
a table of the current CI and what is does

---------

Signed-off-by: Nathan Weinberg <nweinber@redhat.com>

llama_stack/core/routers/datasets.py

@@ -12,7 +12,7 @@ from llama_stack.apis.datasets import DatasetPurpose, DataSource
 from llama_stack.log import get_logger
 from llama_stack.providers.datatypes import RoutingTable
 
-logger = get_logger(name=__name__, category="core")
+log = get_logger(name=__name__, category="core")
 
 
 class DatasetIORouter(DatasetIO):
@@ -20,15 +20,15 @@ class DatasetIORouter(DatasetIO):
         self,
         routing_table: RoutingTable,
     ) -> None:
-        logger.debug("Initializing DatasetIORouter")
+        log.debug("Initializing DatasetIORouter")
         self.routing_table = routing_table
 
     async def initialize(self) -> None:
-        logger.debug("DatasetIORouter.initialize")
+        log.debug("DatasetIORouter.initialize")
         pass
 
     async def shutdown(self) -> None:
-        logger.debug("DatasetIORouter.shutdown")
+        log.debug("DatasetIORouter.shutdown")
         pass
 
     async def register_dataset(
@@ -38,7 +38,7 @@ class DatasetIORouter(DatasetIO):
         metadata: dict[str, Any] | None = None,
         dataset_id: str | None = None,
     ) -> None:
-        logger.debug(
+        log.debug(
             f"DatasetIORouter.register_dataset: {purpose=} {source=} {metadata=} {dataset_id=}",
         )
         await self.routing_table.register_dataset(
@@ -54,7 +54,7 @@ class DatasetIORouter(DatasetIO):
         start_index: int | None = None,
         limit: int | None = None,
     ) -> PaginatedResponse:
-        logger.debug(
+        log.debug(
             f"DatasetIORouter.iterrows: {dataset_id}, {start_index=} {limit=}",
         )
         provider = await self.routing_table.get_provider_impl(dataset_id)
@@ -65,7 +65,7 @@ class DatasetIORouter(DatasetIO):
         )
 
     async def append_rows(self, dataset_id: str, rows: list[dict[str, Any]]) -> None:
-        logger.debug(f"DatasetIORouter.append_rows: {dataset_id}, {len(rows)} rows")
+        log.debug(f"DatasetIORouter.append_rows: {dataset_id}, {len(rows)} rows")
         provider = await self.routing_table.get_provider_impl(dataset_id)
         return await provider.append_rows(
             dataset_id=dataset_id,

llama_stack/core/routers/eval_scoring.py

@@ -16,7 +16,7 @@ from llama_stack.apis.scoring import (
 from llama_stack.log import get_logger
 from llama_stack.providers.datatypes import RoutingTable
 
-logger = get_logger(name=__name__, category="core")
+log = get_logger(name=__name__, category="core")
 
 
 class ScoringRouter(Scoring):
@@ -24,15 +24,15 @@ class ScoringRouter(Scoring):
         self,
         routing_table: RoutingTable,
     ) -> None:
-        logger.debug("Initializing ScoringRouter")
+        log.debug("Initializing ScoringRouter")
         self.routing_table = routing_table
 
     async def initialize(self) -> None:
-        logger.debug("ScoringRouter.initialize")
+        log.debug("ScoringRouter.initialize")
         pass
 
     async def shutdown(self) -> None:
-        logger.debug("ScoringRouter.shutdown")
+        log.debug("ScoringRouter.shutdown")
         pass
 
     async def score_batch(
@@ -41,7 +41,7 @@ class ScoringRouter(Scoring):
         scoring_functions: dict[str, ScoringFnParams | None] = None,
         save_results_dataset: bool = False,
     ) -> ScoreBatchResponse:
-        logger.debug(f"ScoringRouter.score_batch: {dataset_id}")
+        log.debug(f"ScoringRouter.score_batch: {dataset_id}")
         res = {}
         for fn_identifier in scoring_functions.keys():
             provider = await self.routing_table.get_provider_impl(fn_identifier)
@@ -63,7 +63,7 @@ class ScoringRouter(Scoring):
         input_rows: list[dict[str, Any]],
         scoring_functions: dict[str, ScoringFnParams | None] = None,
     ) -> ScoreResponse:
-        logger.debug(f"ScoringRouter.score: {len(input_rows)} rows, {len(scoring_functions)} functions")
+        log.debug(f"ScoringRouter.score: {len(input_rows)} rows, {len(scoring_functions)} functions")
         res = {}
         # look up and map each scoring function to its provider impl
         for fn_identifier in scoring_functions.keys():
@@ -82,15 +82,15 @@ class EvalRouter(Eval):
         self,
         routing_table: RoutingTable,
     ) -> None:
-        logger.debug("Initializing EvalRouter")
+        log.debug("Initializing EvalRouter")
         self.routing_table = routing_table
 
     async def initialize(self) -> None:
-        logger.debug("EvalRouter.initialize")
+        log.debug("EvalRouter.initialize")
         pass
 
     async def shutdown(self) -> None:
-        logger.debug("EvalRouter.shutdown")
+        log.debug("EvalRouter.shutdown")
         pass
 
     async def run_eval(
@@ -98,7 +98,7 @@ class EvalRouter(Eval):
         benchmark_id: str,
         benchmark_config: BenchmarkConfig,
     ) -> Job:
-        logger.debug(f"EvalRouter.run_eval: {benchmark_id}")
+        log.debug(f"EvalRouter.run_eval: {benchmark_id}")
         provider = await self.routing_table.get_provider_impl(benchmark_id)
         return await provider.run_eval(
             benchmark_id=benchmark_id,
@@ -112,7 +112,7 @@ class EvalRouter(Eval):
         scoring_functions: list[str],
         benchmark_config: BenchmarkConfig,
     ) -> EvaluateResponse:
-        logger.debug(f"EvalRouter.evaluate_rows: {benchmark_id}, {len(input_rows)} rows")
+        log.debug(f"EvalRouter.evaluate_rows: {benchmark_id}, {len(input_rows)} rows")
         provider = await self.routing_table.get_provider_impl(benchmark_id)
         return await provider.evaluate_rows(
             benchmark_id=benchmark_id,
@@ -126,7 +126,7 @@ class EvalRouter(Eval):
         benchmark_id: str,
         job_id: str,
     ) -> Job:
-        logger.debug(f"EvalRouter.job_status: {benchmark_id}, {job_id}")
+        log.debug(f"EvalRouter.job_status: {benchmark_id}, {job_id}")
         provider = await self.routing_table.get_provider_impl(benchmark_id)
         return await provider.job_status(benchmark_id, job_id)
 
@@ -135,7 +135,7 @@ class EvalRouter(Eval):
         benchmark_id: str,
         job_id: str,
     ) -> None:
-        logger.debug(f"EvalRouter.job_cancel: {benchmark_id}, {job_id}")
+        log.debug(f"EvalRouter.job_cancel: {benchmark_id}, {job_id}")
         provider = await self.routing_table.get_provider_impl(benchmark_id)
         await provider.job_cancel(
             benchmark_id,
@@ -147,7 +147,7 @@ class EvalRouter(Eval):
         benchmark_id: str,
         job_id: str,
     ) -> EvaluateResponse:
-        logger.debug(f"EvalRouter.job_result: {benchmark_id}, {job_id}")
+        log.debug(f"EvalRouter.job_result: {benchmark_id}, {job_id}")
         provider = await self.routing_table.get_provider_impl(benchmark_id)
         return await provider.job_result(
             benchmark_id,

llama_stack/core/routers/inference.py

@@ -58,7 +58,7 @@ from llama_stack.providers.utils.inference.inference_store import InferenceStore
 from llama_stack.providers.utils.inference.stream_utils import stream_and_store_openai_completion
 from llama_stack.providers.utils.telemetry.tracing import get_current_span
 
-logger = get_logger(name=__name__, category="core")
+log = get_logger(name=__name__, category="core")
 
 
 class InferenceRouter(Inference):
@@ -70,7 +70,7 @@ class InferenceRouter(Inference):
         telemetry: Telemetry | None = None,
         store: InferenceStore | None = None,
     ) -> None:
-        logger.debug("Initializing InferenceRouter")
+        log.debug("Initializing InferenceRouter")
         self.routing_table = routing_table
         self.telemetry = telemetry
         self.store = store
@@ -79,10 +79,10 @@ class InferenceRouter(Inference):
             self.formatter = ChatFormat(self.tokenizer)
 
     async def initialize(self) -> None:
-        logger.debug("InferenceRouter.initialize")
+        log.debug("InferenceRouter.initialize")
 
     async def shutdown(self) -> None:
-        logger.debug("InferenceRouter.shutdown")
+        log.debug("InferenceRouter.shutdown")
 
     async def register_model(
         self,
@@ -92,7 +92,7 @@ class InferenceRouter(Inference):
         metadata: dict[str, Any] | None = None,
         model_type: ModelType | None = None,
     ) -> None:
-        logger.debug(
+        log.debug(
             f"InferenceRouter.register_model: {model_id=} {provider_model_id=} {provider_id=} {metadata=} {model_type=}",
         )
         await self.routing_table.register_model(model_id, provider_model_id, provider_id, metadata, model_type)
@@ -117,7 +117,7 @@ class InferenceRouter(Inference):
         """
         span = get_current_span()
         if span is None:
-            logger.warning("No span found for token usage metrics")
+            log.warning("No span found for token usage metrics")
             return []
         metrics = [
             ("prompt_tokens", prompt_tokens),
@@ -182,7 +182,7 @@ class InferenceRouter(Inference):
         logprobs: LogProbConfig | None = None,
         tool_config: ToolConfig | None = None,
     ) -> ChatCompletionResponse | AsyncIterator[ChatCompletionResponseStreamChunk]:
-        logger.debug(
+        log.debug(
             f"InferenceRouter.chat_completion: {model_id=}, {stream=}, {messages=}, {tools=}, {tool_config=}, {response_format=}",
         )
         if sampling_params is None:
@@ -288,7 +288,7 @@ class InferenceRouter(Inference):
         response_format: ResponseFormat | None = None,
         logprobs: LogProbConfig | None = None,
     ) -> BatchChatCompletionResponse:
-        logger.debug(
+        log.debug(
             f"InferenceRouter.batch_chat_completion: {model_id=}, {len(messages_batch)=}, {sampling_params=}, {response_format=}, {logprobs=}",
         )
         provider = await self.routing_table.get_provider_impl(model_id)
@@ -313,7 +313,7 @@ class InferenceRouter(Inference):
     ) -> AsyncGenerator:
         if sampling_params is None:
             sampling_params = SamplingParams()
-        logger.debug(
+        log.debug(
             f"InferenceRouter.completion: {model_id=}, {stream=}, {content=}, {sampling_params=}, {response_format=}",
         )
         model = await self.routing_table.get_model(model_id)
@@ -374,7 +374,7 @@ class InferenceRouter(Inference):
         response_format: ResponseFormat | None = None,
         logprobs: LogProbConfig | None = None,
     ) -> BatchCompletionResponse:
-        logger.debug(
+        log.debug(
             f"InferenceRouter.batch_completion: {model_id=}, {len(content_batch)=}, {sampling_params=}, {response_format=}, {logprobs=}",
         )
         provider = await self.routing_table.get_provider_impl(model_id)
@@ -388,7 +388,7 @@ class InferenceRouter(Inference):
         output_dimension: int | None = None,
         task_type: EmbeddingTaskType | None = None,
     ) -> EmbeddingsResponse:
-        logger.debug(f"InferenceRouter.embeddings: {model_id}")
+        log.debug(f"InferenceRouter.embeddings: {model_id}")
         model = await self.routing_table.get_model(model_id)
         if model is None:
             raise ModelNotFoundError(model_id)
@@ -426,7 +426,7 @@ class InferenceRouter(Inference):
         prompt_logprobs: int | None = None,
         suffix: str | None = None,
     ) -> OpenAICompletion:
-        logger.debug(
+        log.debug(
             f"InferenceRouter.openai_completion: {model=}, {stream=}, {prompt=}",
         )
         model_obj = await self.routing_table.get_model(model)
@@ -487,7 +487,7 @@ class InferenceRouter(Inference):
         top_p: float | None = None,
         user: str | None = None,
     ) -> OpenAIChatCompletion | AsyncIterator[OpenAIChatCompletionChunk]:
-        logger.debug(
+        log.debug(
             f"InferenceRouter.openai_chat_completion: {model=}, {stream=}, {messages=}",
         )
         model_obj = await self.routing_table.get_model(model)
@@ -558,7 +558,7 @@ class InferenceRouter(Inference):
         dimensions: int | None = None,
         user: str | None = None,
     ) -> OpenAIEmbeddingsResponse:
-        logger.debug(
+        log.debug(
             f"InferenceRouter.openai_embeddings: {model=}, input_type={type(input)}, {encoding_format=}, {dimensions=}",
         )
         model_obj = await self.routing_table.get_model(model)

llama_stack/core/routers/safety.py

@@ -14,7 +14,7 @@ from llama_stack.apis.shields import Shield
 from llama_stack.log import get_logger
 from llama_stack.providers.datatypes import RoutingTable
 
-logger = get_logger(name=__name__, category="core")
+log = get_logger(name=__name__, category="core")
 
 
 class SafetyRouter(Safety):
@@ -22,15 +22,15 @@ class SafetyRouter(Safety):
         self,
         routing_table: RoutingTable,
     ) -> None:
-        logger.debug("Initializing SafetyRouter")
+        log.debug("Initializing SafetyRouter")
         self.routing_table = routing_table
 
     async def initialize(self) -> None:
-        logger.debug("SafetyRouter.initialize")
+        log.debug("SafetyRouter.initialize")
         pass
 
     async def shutdown(self) -> None:
-        logger.debug("SafetyRouter.shutdown")
+        log.debug("SafetyRouter.shutdown")
         pass
 
     async def register_shield(
@@ -40,7 +40,7 @@ class SafetyRouter(Safety):
         provider_id: str | None = None,
         params: dict[str, Any] | None = None,
     ) -> Shield:
-        logger.debug(f"SafetyRouter.register_shield: {shield_id}")
+        log.debug(f"SafetyRouter.register_shield: {shield_id}")
         return await self.routing_table.register_shield(shield_id, provider_shield_id, provider_id, params)
 
     async def unregister_shield(self, identifier: str) -> None:
@@ -53,7 +53,7 @@ class SafetyRouter(Safety):
         messages: list[Message],
         params: dict[str, Any] = None,
     ) -> RunShieldResponse:
-        logger.debug(f"SafetyRouter.run_shield: {shield_id}")
+        log.debug(f"SafetyRouter.run_shield: {shield_id}")
         provider = await self.routing_table.get_provider_impl(shield_id)
         return await provider.run_shield(
             shield_id=shield_id,

llama_stack/core/routers/tool_runtime.py

@@ -22,7 +22,7 @@ from llama_stack.log import get_logger
 
 from ..routing_tables.toolgroups import ToolGroupsRoutingTable
 
-logger = get_logger(name=__name__, category="core")
+log = get_logger(name=__name__, category="core")
 
 
 class ToolRuntimeRouter(ToolRuntime):
@@ -31,7 +31,7 @@ class ToolRuntimeRouter(ToolRuntime):
             self,
             routing_table: ToolGroupsRoutingTable,
         ) -> None:
-            logger.debug("Initializing ToolRuntimeRouter.RagToolImpl")
+            log.debug("Initializing ToolRuntimeRouter.RagToolImpl")
             self.routing_table = routing_table
 
         async def query(
@@ -40,7 +40,7 @@ class ToolRuntimeRouter(ToolRuntime):
             vector_db_ids: list[str],
             query_config: RAGQueryConfig | None = None,
         ) -> RAGQueryResult:
-            logger.debug(f"ToolRuntimeRouter.RagToolImpl.query: {vector_db_ids}")
+            log.debug(f"ToolRuntimeRouter.RagToolImpl.query: {vector_db_ids}")
             provider = await self.routing_table.get_provider_impl("knowledge_search")
             return await provider.query(content, vector_db_ids, query_config)
 
@@ -50,7 +50,7 @@ class ToolRuntimeRouter(ToolRuntime):
             vector_db_id: str,
             chunk_size_in_tokens: int = 512,
         ) -> None:
-            logger.debug(
+            log.debug(
                 f"ToolRuntimeRouter.RagToolImpl.insert: {vector_db_id}, {len(documents)} documents, chunk_size={chunk_size_in_tokens}"
             )
             provider = await self.routing_table.get_provider_impl("insert_into_memory")
@@ -60,7 +60,7 @@ class ToolRuntimeRouter(ToolRuntime):
         self,
         routing_table: ToolGroupsRoutingTable,
     ) -> None:
-        logger.debug("Initializing ToolRuntimeRouter")
+        log.debug("Initializing ToolRuntimeRouter")
         self.routing_table = routing_table
 
         # HACK ALERT this should be in sync with "get_all_api_endpoints()"
@@ -69,15 +69,15 @@ class ToolRuntimeRouter(ToolRuntime):
             setattr(self, f"rag_tool.{method}", getattr(self.rag_tool, method))
 
     async def initialize(self) -> None:
-        logger.debug("ToolRuntimeRouter.initialize")
+        log.debug("ToolRuntimeRouter.initialize")
         pass
 
     async def shutdown(self) -> None:
-        logger.debug("ToolRuntimeRouter.shutdown")
+        log.debug("ToolRuntimeRouter.shutdown")
         pass
 
     async def invoke_tool(self, tool_name: str, kwargs: dict[str, Any]) -> Any:
-        logger.debug(f"ToolRuntimeRouter.invoke_tool: {tool_name}")
+        log.debug(f"ToolRuntimeRouter.invoke_tool: {tool_name}")
         provider = await self.routing_table.get_provider_impl(tool_name)
         return await provider.invoke_tool(
             tool_name=tool_name,
@@ -87,5 +87,5 @@ class ToolRuntimeRouter(ToolRuntime):
     async def list_runtime_tools(
         self, tool_group_id: str | None = None, mcp_endpoint: URL | None = None
     ) -> ListToolsResponse:
-        logger.debug(f"ToolRuntimeRouter.list_runtime_tools: {tool_group_id}")
+        log.debug(f"ToolRuntimeRouter.list_runtime_tools: {tool_group_id}")
         return await self.routing_table.list_tools(tool_group_id)

llama_stack/core/routers/vector_io.py

@@ -30,7 +30,7 @@ from llama_stack.apis.vector_io import (
 from llama_stack.log import get_logger
 from llama_stack.providers.datatypes import HealthResponse, HealthStatus, RoutingTable
 
-logger = get_logger(name=__name__, category="core")
+log = get_logger(name=__name__, category="core")
 
 
 class VectorIORouter(VectorIO):
@@ -40,15 +40,15 @@ class VectorIORouter(VectorIO):
         self,
         routing_table: RoutingTable,
     ) -> None:
-        logger.debug("Initializing VectorIORouter")
+        log.debug("Initializing VectorIORouter")
         self.routing_table = routing_table
 
     async def initialize(self) -> None:
-        logger.debug("VectorIORouter.initialize")
+        log.debug("VectorIORouter.initialize")
         pass
 
     async def shutdown(self) -> None:
-        logger.debug("VectorIORouter.shutdown")
+        log.debug("VectorIORouter.shutdown")
         pass
 
     async def _get_first_embedding_model(self) -> tuple[str, int] | None:
@@ -70,10 +70,10 @@ class VectorIORouter(VectorIO):
                     raise ValueError(f"Embedding model {embedding_models[0].identifier} has no embedding dimension")
                 return embedding_models[0].identifier, dimension
             else:
-                logger.warning("No embedding models found in the routing table")
+                log.warning("No embedding models found in the routing table")
                 return None
         except Exception as e:
-            logger.error(f"Error getting embedding models: {e}")
+            log.error(f"Error getting embedding models: {e}")
             return None
 
     async def register_vector_db(
@@ -85,7 +85,7 @@ class VectorIORouter(VectorIO):
         vector_db_name: str | None = None,
         provider_vector_db_id: str | None = None,
     ) -> None:
-        logger.debug(f"VectorIORouter.register_vector_db: {vector_db_id}, {embedding_model}")
+        log.debug(f"VectorIORouter.register_vector_db: {vector_db_id}, {embedding_model}")
         await self.routing_table.register_vector_db(
             vector_db_id,
             embedding_model,
@@ -101,7 +101,7 @@ class VectorIORouter(VectorIO):
         chunks: list[Chunk],
         ttl_seconds: int | None = None,
     ) -> None:
-        logger.debug(
+        log.debug(
             f"VectorIORouter.insert_chunks: {vector_db_id}, {len(chunks)} chunks, ttl_seconds={ttl_seconds}, chunk_ids={[chunk.metadata['document_id'] for chunk in chunks[:3]]}{' and more...' if len(chunks) > 3 else ''}",
         )
         provider = await self.routing_table.get_provider_impl(vector_db_id)
@@ -113,7 +113,7 @@ class VectorIORouter(VectorIO):
         query: InterleavedContent,
         params: dict[str, Any] | None = None,
     ) -> QueryChunksResponse:
-        logger.debug(f"VectorIORouter.query_chunks: {vector_db_id}")
+        log.debug(f"VectorIORouter.query_chunks: {vector_db_id}")
         provider = await self.routing_table.get_provider_impl(vector_db_id)
         return await provider.query_chunks(vector_db_id, query, params)
 
@@ -129,7 +129,7 @@ class VectorIORouter(VectorIO):
         embedding_dimension: int | None = None,
         provider_id: str | None = None,
     ) -> VectorStoreObject:
-        logger.debug(f"VectorIORouter.openai_create_vector_store: name={name}, provider_id={provider_id}")
+        log.debug(f"VectorIORouter.openai_create_vector_store: name={name}, provider_id={provider_id}")
 
         # If no embedding model is provided, use the first available one
         if embedding_model is None:
@@ -137,7 +137,7 @@ class VectorIORouter(VectorIO):
             if embedding_model_info is None:
                 raise ValueError("No embedding model provided and no embedding models available in the system")
             embedding_model, embedding_dimension = embedding_model_info
-            logger.info(f"No embedding model specified, using first available: {embedding_model}")
+            log.info(f"No embedding model specified, using first available: {embedding_model}")
 
         vector_db_id = f"vs_{uuid.uuid4()}"
         registered_vector_db = await self.routing_table.register_vector_db(
@@ -168,7 +168,7 @@ class VectorIORouter(VectorIO):
         after: str | None = None,
         before: str | None = None,
     ) -> VectorStoreListResponse:
-        logger.debug(f"VectorIORouter.openai_list_vector_stores: limit={limit}")
+        log.debug(f"VectorIORouter.openai_list_vector_stores: limit={limit}")
         # Route to default provider for now - could aggregate from all providers in the future
         # call retrieve on each vector dbs to get list of vector stores
         vector_dbs = await self.routing_table.get_all_with_type("vector_db")
@@ -179,7 +179,7 @@ class VectorIORouter(VectorIO):
                 vector_store = await provider.openai_retrieve_vector_store(vector_db.identifier)
                 all_stores.append(vector_store)
             except Exception as e:
-                logger.error(f"Error retrieving vector store {vector_db.identifier}: {e}")
+                log.error(f"Error retrieving vector store {vector_db.identifier}: {e}")
                 continue
 
         # Sort by created_at
@@ -215,7 +215,7 @@ class VectorIORouter(VectorIO):
         self,
         vector_store_id: str,
     ) -> VectorStoreObject:
-        logger.debug(f"VectorIORouter.openai_retrieve_vector_store: {vector_store_id}")
+        log.debug(f"VectorIORouter.openai_retrieve_vector_store: {vector_store_id}")
         return await self.routing_table.openai_retrieve_vector_store(vector_store_id)
 
     async def openai_update_vector_store(
@@ -225,7 +225,7 @@ class VectorIORouter(VectorIO):
         expires_after: dict[str, Any] | None = None,
         metadata: dict[str, Any] | None = None,
     ) -> VectorStoreObject:
-        logger.debug(f"VectorIORouter.openai_update_vector_store: {vector_store_id}")
+        log.debug(f"VectorIORouter.openai_update_vector_store: {vector_store_id}")
         return await self.routing_table.openai_update_vector_store(
             vector_store_id=vector_store_id,
             name=name,
@@ -237,7 +237,7 @@ class VectorIORouter(VectorIO):
         self,
         vector_store_id: str,
     ) -> VectorStoreDeleteResponse:
-        logger.debug(f"VectorIORouter.openai_delete_vector_store: {vector_store_id}")
+        log.debug(f"VectorIORouter.openai_delete_vector_store: {vector_store_id}")
         return await self.routing_table.openai_delete_vector_store(vector_store_id)
 
     async def openai_search_vector_store(
@@ -250,7 +250,7 @@ class VectorIORouter(VectorIO):
         rewrite_query: bool | None = False,
         search_mode: str | None = "vector",
     ) -> VectorStoreSearchResponsePage:
-        logger.debug(f"VectorIORouter.openai_search_vector_store: {vector_store_id}")
+        log.debug(f"VectorIORouter.openai_search_vector_store: {vector_store_id}")
         return await self.routing_table.openai_search_vector_store(
             vector_store_id=vector_store_id,
             query=query,
@@ -268,7 +268,7 @@ class VectorIORouter(VectorIO):
         attributes: dict[str, Any] | None = None,
         chunking_strategy: VectorStoreChunkingStrategy | None = None,
     ) -> VectorStoreFileObject:
-        logger.debug(f"VectorIORouter.openai_attach_file_to_vector_store: {vector_store_id}, {file_id}")
+        log.debug(f"VectorIORouter.openai_attach_file_to_vector_store: {vector_store_id}, {file_id}")
         return await self.routing_table.openai_attach_file_to_vector_store(
             vector_store_id=vector_store_id,
             file_id=file_id,
@@ -285,7 +285,7 @@ class VectorIORouter(VectorIO):
         before: str | None = None,
         filter: VectorStoreFileStatus | None = None,
     ) -> list[VectorStoreFileObject]:
-        logger.debug(f"VectorIORouter.openai_list_files_in_vector_store: {vector_store_id}")
+        log.debug(f"VectorIORouter.openai_list_files_in_vector_store: {vector_store_id}")
         return await self.routing_table.openai_list_files_in_vector_store(
             vector_store_id=vector_store_id,
             limit=limit,
@@ -300,7 +300,7 @@ class VectorIORouter(VectorIO):
         vector_store_id: str,
         file_id: str,
     ) -> VectorStoreFileObject:
-        logger.debug(f"VectorIORouter.openai_retrieve_vector_store_file: {vector_store_id}, {file_id}")
+        log.debug(f"VectorIORouter.openai_retrieve_vector_store_file: {vector_store_id}, {file_id}")
         return await self.routing_table.openai_retrieve_vector_store_file(
             vector_store_id=vector_store_id,
             file_id=file_id,
@@ -311,7 +311,7 @@ class VectorIORouter(VectorIO):
         vector_store_id: str,
         file_id: str,
     ) -> VectorStoreFileContentsResponse:
-        logger.debug(f"VectorIORouter.openai_retrieve_vector_store_file_contents: {vector_store_id}, {file_id}")
+        log.debug(f"VectorIORouter.openai_retrieve_vector_store_file_contents: {vector_store_id}, {file_id}")
         return await self.routing_table.openai_retrieve_vector_store_file_contents(
             vector_store_id=vector_store_id,
             file_id=file_id,
@@ -323,7 +323,7 @@ class VectorIORouter(VectorIO):
         file_id: str,
         attributes: dict[str, Any],
     ) -> VectorStoreFileObject:
-        logger.debug(f"VectorIORouter.openai_update_vector_store_file: {vector_store_id}, {file_id}")
+        log.debug(f"VectorIORouter.openai_update_vector_store_file: {vector_store_id}, {file_id}")
         return await self.routing_table.openai_update_vector_store_file(
             vector_store_id=vector_store_id,
             file_id=file_id,
@@ -335,7 +335,7 @@ class VectorIORouter(VectorIO):
         vector_store_id: str,
         file_id: str,
     ) -> VectorStoreFileDeleteResponse:
-        logger.debug(f"VectorIORouter.openai_delete_vector_store_file: {vector_store_id}, {file_id}")
+        log.debug(f"VectorIORouter.openai_delete_vector_store_file: {vector_store_id}, {file_id}")
         return await self.routing_table.openai_delete_vector_store_file(
             vector_store_id=vector_store_id,
             file_id=file_id,