lionagi 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

lionagi/integrations/openai_/api_endpoints/images/image_variation_models.py

@@ -0,0 +1,56 @@
+from enum import Enum
+from typing import IO, Literal, Optional
+
+from pydantic import ConfigDict, Field, field_validator
+
+from ..data_models import OpenAIEndpointRequestBody
+
+
+class Size(str, Enum):
+    S256 = "256x256"
+    S512 = "512x512"
+    S1024 = "1024x1024"
+
+
+class OpenAIImageVariationRequestBody(OpenAIEndpointRequestBody):
+    image: str | IO = Field(
+        description="The image to use as the basis for the variation(s). "
+        "Must be a valid PNG file, less than 4MB, and square.",
+    )
+
+    model: Literal["dall-e-2"] | None = Field(
+        "dall-e-2", description="The model to use for image generation."
+    )
+
+    n: int | None = Field(
+        1, description="The number of images to generate.", ge=1, le=10
+    )
+
+    response_format: Literal["url", "b64_json"] | None = Field(
+        "url",
+        description="The format in which the generated images are returned.",
+    )
+
+    size: Size | None = Field(
+        "1024x1024", description="The size of the generated images."
+    )
+
+    user: str | None = Field(
+        None,
+        description="A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.",
+    )
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @field_validator("image")
+    @classmethod
+    def get_file_object(cls, value):
+        if isinstance(value, str):
+            value = open(value, "rb")
+        return value
+
+    def __del__(self):
+        # Ensure files are closed when the object is destroyed
+        image_obj = self.__dict__.get("image")
+        if image_obj and not image_obj.closed:
+            image_obj.close()

lionagi/integrations/openai_/api_endpoints/images/response_body.py

@@ -0,0 +1,30 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from ..data_models import OpenAIEndpointRequestBody
+
+
+class Image(BaseModel):
+    b64_json: str | None = Field(
+        None,
+        description="The base64-encoded JSON of the generated image, if response_format is b64_json.",
+    )
+
+    url: str | None = Field(
+        None,
+        description="The URL of the generated image, if response_format is url (default).",
+    )
+
+    revised_prompt: str | None = Field(
+        None,
+        description="The prompt that was used to generate the image, if there was any revision to the prompt.",
+    )
+
+
+class OpenAIImageResponseBody(OpenAIEndpointRequestBody):
+    created: int = Field(
+        description="The Unix timestamp of when the image was created."
+    )
+
+    data: list[Image] = Field(description="The list of generated images.")

lionagi/integrations/openai_/api_endpoints/match_data_model.py

@@ -0,0 +1,197 @@
+def match_data_model(task_name):
+    if task_name == "create_speech":
+        from lionagi.integrations.openai_.api_endpoints.audio.speech_models import (
+            OpenAISpeechRequestBody,
+        )
+
+        return {"request_body": OpenAISpeechRequestBody}
+    elif task_name == "create_transcription":
+        from lionagi.integrations.openai_.api_endpoints.audio.transcription_models import (
+            OpenAITranscriptionRequestBody,
+        )
+
+        return {"request_body": OpenAITranscriptionRequestBody}
+    elif task_name == "create_translation":
+        from lionagi.integrations.openai_.api_endpoints.audio.translation_models import (
+            OpenAITranslationRequestBody,
+        )
+
+        return {"request_body": OpenAITranslationRequestBody}
+    elif task_name == "create_chat_completion":
+        from lionagi.integrations.openai_.api_endpoints.chat_completions.request.request_body import (
+            OpenAIChatCompletionRequestBody,
+        )
+
+        return {"request_body": OpenAIChatCompletionRequestBody}
+    elif task_name == "create_embeddings":
+        from lionagi.integrations.openai_.api_endpoints.embeddings.request_body import (
+            OpenAIEmbeddingRequestBody,
+        )
+
+        return {"request_body": OpenAIEmbeddingRequestBody}
+    elif task_name == "create_fine_tuning_job":
+        from lionagi.integrations.openai_.api_endpoints.fine_tuning.create_jobs import (
+            OpenAICreateFineTuningJobRequestBody,
+        )
+
+        return {"json_data": OpenAICreateFineTuningJobRequestBody}
+    elif task_name == "list_fine_tuning_jobs":
+        from lionagi.integrations.openai_.api_endpoints.fine_tuning.list_fine_tuning_jobs import (
+            OpenAIListFineTuningJobsQueryParam,
+        )
+
+        return {"params": OpenAIListFineTuningJobsQueryParam}
+    elif task_name == "list_fine_tuning_events":
+        from lionagi.integrations.openai_.api_endpoints.fine_tuning.list_fine_tuning_events import (
+            OpenAIListFineTuningEventsPathParam,
+            OpenAIListFineTuningEventsQueryParam,
+        )
+
+        return {
+            "params": OpenAIListFineTuningEventsQueryParam,
+            "path_param": OpenAIListFineTuningEventsPathParam,
+        }
+    elif task_name == "list_fine_tuning_checkpoints":
+        from lionagi.integrations.openai_.api_endpoints.fine_tuning.list_fine_tuning_checkpoints import (
+            OpenAIListFineTuningCheckpointsPathParam,
+            OpenAIListFineTuningCheckpointsQueryParam,
+        )
+
+        return {
+            "params": OpenAIListFineTuningCheckpointsQueryParam,
+            "path_param": OpenAIListFineTuningCheckpointsPathParam,
+        }
+    elif task_name == "retrieve_fine_tuning_job":
+        from lionagi.integrations.openai_.api_endpoints.fine_tuning.retrieve_jobs import (
+            OpenAIRetrieveFineTuningJobPathParam,
+        )
+
+        return {"path_param": OpenAIRetrieveFineTuningJobPathParam}
+    elif task_name == "cancel_fine_tuning":
+        from lionagi.integrations.openai_.api_endpoints.fine_tuning.cancel_jobs import (
+            OpenAICancelFineTuningPathParam,
+        )
+
+        return {"path_param": OpenAICancelFineTuningPathParam}
+    elif task_name == "create_batch":
+        from lionagi.integrations.openai_.api_endpoints.batch.create_batch import (
+            OpenAIBatchRequestBody,
+        )
+
+        return {"json_data": OpenAIBatchRequestBody}
+    elif task_name == "retrieve_batch":
+        from lionagi.integrations.openai_.api_endpoints.batch.retrieve_batch import (
+            OpenAIRetrieveBatchPathParam,
+        )
+
+        return {"path_param": OpenAIRetrieveBatchPathParam}
+    elif task_name == "cancel_batch":
+        from lionagi.integrations.openai_.api_endpoints.batch.cancel_batch import (
+            OpenAICancelBatchPathParam,
+        )
+
+        return {"path_param": OpenAICancelBatchPathParam}
+    elif task_name == "list_batch":
+        from lionagi.integrations.openai_.api_endpoints.batch.list_batch import (
+            OpenAIListBatchQueryParam,
+        )
+
+        return {"params": OpenAIListBatchQueryParam}
+    elif task_name == "upload_file":
+        from lionagi.integrations.openai_.api_endpoints.files.upload_file import (
+            OpenAIUploadFileRequestBody,
+        )
+
+        return {"form_data": OpenAIUploadFileRequestBody}
+    elif task_name == "list_files":
+        from lionagi.integrations.openai_.api_endpoints.files.list_files import (
+            OpenAIListFilesQueryParam,
+        )
+
+        return {"params": OpenAIListFilesQueryParam}
+    elif task_name == "retrieve_file" or task_name == "retrieve_file_content":
+        from lionagi.integrations.openai_.api_endpoints.files.retrieve_file import (
+            OpenAIRetrieveFilePathParam,
+        )
+
+        return {"path_param": OpenAIRetrieveFilePathParam}
+    elif task_name == "delete_file":
+        from lionagi.integrations.openai_.api_endpoints.files.delete_file import (
+            OpenAIDeleteFilePathParam,
+        )
+
+        return {"path_param": OpenAIDeleteFilePathParam}
+    elif task_name == "create_upload":
+        from lionagi.integrations.openai_.api_endpoints.uploads.create_upload import (
+            OpenAIUploadRequestBody,
+        )
+
+        return {"json_data": OpenAIUploadRequestBody}
+    elif task_name == "add_upload_part":
+        from lionagi.integrations.openai_.api_endpoints.uploads.add_upload_part import (
+            OpenAIUploadPartPathParam,
+            OpenAIUploadPartRequestBody,
+        )
+
+        return {
+            "path_param": OpenAIUploadPartPathParam,
+            "form_data": OpenAIUploadPartRequestBody,
+        }
+    elif task_name == "complete_upload":
+        from lionagi.integrations.openai_.api_endpoints.uploads.complete_upload import (
+            OpenAICompleteUploadPathParam,
+            OpenAICompleteUploadRequestBody,
+        )
+
+        return {
+            "path_param": OpenAICompleteUploadPathParam,
+            "json_data": OpenAICompleteUploadRequestBody,
+        }
+    elif task_name == "cancel_upload":
+        from lionagi.integrations.openai_.api_endpoints.uploads.cancel_upload import (
+            OpenAICancelUploadPathParam,
+        )
+
+        return {"path_param": OpenAICancelUploadPathParam}
+    elif task_name == "create_image":
+        from lionagi.integrations.openai_.api_endpoints.images.image_models import (
+            OpenAIImageRequestBody,
+        )
+
+        return {"json_data": OpenAIImageRequestBody}
+    elif task_name == "create_image_edit":
+        from lionagi.integrations.openai_.api_endpoints.images.image_edit_models import (
+            OpenAIImageEditRequestBody,
+        )
+
+        return {"form_data": OpenAIImageEditRequestBody}
+    elif task_name == "create_image_variation":
+        from lionagi.integrations.openai_.api_endpoints.images.image_variation_models import (
+            OpenAIImageVariationRequestBody,
+        )
+
+        return {"form_data": OpenAIImageVariationRequestBody}
+    elif task_name == "list_models":
+        return {}
+    elif task_name == "retrieve_model":
+        from lionagi.integrations.openai_.api_endpoints.models.retrieve_model import (
+            OpenAIRetrieveModelPathParam,
+        )
+
+        return {"path_param": OpenAIRetrieveModelPathParam}
+    elif task_name == "delete_fine_tuned_model":
+        from lionagi.integrations.openai_.api_endpoints.models.delete_fine_tuned_model import (
+            OpenAIDeleteFineTunedModelPathParam,
+        )
+
+        return {"path_param": OpenAIDeleteFineTunedModelPathParam}
+    elif task_name == "create_moderation":
+        from lionagi.integrations.openai_.api_endpoints.moderations.request_body import (
+            OpenAIModerationRequestBody,
+        )
+
+        return {"json_data": OpenAIModerationRequestBody}
+    else:
+        raise ValueError(
+            f"Invalid task: {task_name}. Not supported in the service."
+        )

lionagi/integrations/openai_/api_endpoints/match_response.py

@@ -0,0 +1,336 @@
+imported_models = {}
+
+
+def match_response(request_model, response: dict | list):
+    global imported_models
+
+    endpoint = request_model.endpoint
+    method = request_model.method
+
+    # audio
+    if "audio" in endpoint:
+        # create transcription
+        if endpoint == "audio/transcriptions":
+            if len(response) == 1:
+                # transcription object
+                if "OpenAITranscriptionResponseBody" not in imported_models:
+                    from .audio.transcription_models import (
+                        OpenAITranscriptionResponseBody,
+                    )
+
+                    imported_models["OpenAITranscriptionResponseBody"] = (
+                        OpenAITranscriptionResponseBody
+                    )
+                return imported_models["OpenAITranscriptionResponseBody"](
+                    **response
+                )
+            else:
+                # verbose transcription object
+                if (
+                    "OpenAIVerboseTranscriptionResponseBody"
+                    not in imported_models
+                ):
+                    from .audio.transcription_models import (
+                        OpenAIVerboseTranscriptionResponseBody,
+                    )
+
+                    imported_models[
+                        "OpenAIVerboseTranscriptionResponseBody"
+                    ] = OpenAIVerboseTranscriptionResponseBody
+                return imported_models[
+                    "OpenAIVerboseTranscriptionResponseBody"
+                ](**response)
+
+        # create translation
+        if endpoint == "audio/translations":
+            if "OpenAITranslationResponseBody" not in imported_models:
+                from .audio.translation_models import (
+                    OpenAITranslationResponseBody,
+                )
+
+                imported_models["OpenAITranslationResponseBody"] = (
+                    OpenAITranslationResponseBody
+                )
+            return imported_models["OpenAITranslationResponseBody"](**response)
+
+    # Chat
+    elif endpoint == "chat/completions":
+        if isinstance(response, dict):
+            if "OpenAIChatCompletionResponseBody" not in imported_models:
+                from .chat_completions.response.response_body import (
+                    OpenAIChatCompletionResponseBody,
+                )
+
+                imported_models["OpenAIChatCompletionResponseBody"] = (
+                    OpenAIChatCompletionResponseBody
+                )
+            return imported_models["OpenAIChatCompletionResponseBody"](
+                **response
+            )
+        else:
+            # stream list
+            if "OpenAIChatCompletionChunkResponseBody" not in imported_models:
+                from .chat_completions.response.response_body import (
+                    OpenAIChatCompletionChunkResponseBody,
+                )
+
+                imported_models["OpenAIChatCompletionChunkResponseBody"] = (
+                    OpenAIChatCompletionChunkResponseBody
+                )
+            result = []
+            for item in response:
+                result.append(
+                    imported_models["OpenAIChatCompletionChunkResponseBody"](
+                        **item
+                    )
+                )
+            return result
+
+    # Embeddings
+    elif endpoint == "embeddings":
+        if "OpenAIEmbeddingResponseBody" not in imported_models:
+            from .embeddings.response_body import OpenAIEmbeddingResponseBody
+
+            imported_models["OpenAIEmbeddingResponseBody"] = (
+                OpenAIEmbeddingResponseBody
+            )
+        return imported_models["OpenAIEmbeddingResponseBody"](**response)
+
+    # Fine-tuning
+    elif "fine_tuning" in endpoint:
+        # create fine-tuning job
+        if endpoint == "fine_tuning/jobs" and method == "POST":
+            if "OpenAIFineTuningJobResponseBody" not in imported_models:
+                from .fine_tuning.fine_tuning_job_models import (
+                    OpenAIFineTuningJobResponseBody,
+                )
+
+                imported_models["OpenAIFineTuningJobResponseBody"] = (
+                    OpenAIFineTuningJobResponseBody
+                )
+            return imported_models["OpenAIFineTuningJobResponseBody"](
+                **response
+            )
+
+        # list fine-tuning jobs
+        if endpoint == "fine_tuning/jobs" and method == "GET":
+            if "OpenAIListFineTuningJobsResponseBody" not in imported_models:
+                from .fine_tuning.list_fine_tuning_jobs import (
+                    OpenAIListFineTuningJobsResponseBody,
+                )
+
+                imported_models["OpenAIListFineTuningJobsResponseBody"] = (
+                    OpenAIListFineTuningJobsResponseBody
+                )
+            return imported_models["OpenAIListFineTuningJobsResponseBody"](
+                **response
+            )
+
+        # list fine-tuning events
+        if endpoint == "fine_tuning/jobs/{fine_tuning_job_id}/events":
+            if "OpenAIListFineTuningEventsResponseBody" not in imported_models:
+                from .fine_tuning.list_fine_tuning_events import (
+                    OpenAIListFineTuningEventsResponseBody,
+                )
+
+                imported_models["OpenAIListFineTuningEventsResponseBody"] = (
+                    OpenAIListFineTuningEventsResponseBody
+                )
+            return imported_models["OpenAIListFineTuningEventsResponseBody"](
+                **response
+            )
+
+        # list fine-tuning checkpoints
+        if endpoint == "fine_tuning/jobs/{fine_tuning_job_id}/checkpoints":
+            if (
+                "OpenAIListFineTuningCheckpointsResponseBody"
+                not in imported_models
+            ):
+                from .fine_tuning.list_fine_tuning_checkpoints import (
+                    OpenAIListFineTuningCheckpointsResponseBody,
+                )
+
+                imported_models[
+                    "OpenAIListFineTuningCheckpointsResponseBody"
+                ] = OpenAIListFineTuningCheckpointsResponseBody
+            return imported_models[
+                "OpenAIListFineTuningCheckpointsResponseBody"
+            ](**response)
+
+        # retrieve fine-tuning job
+        if endpoint == "fine_tuning/jobs/{fine_tuning_job_id}":
+            if "OpenAIFineTuningJobResponseBody" not in imported_models:
+                from .fine_tuning.fine_tuning_job_models import (
+                    OpenAIFineTuningJobResponseBody,
+                )
+
+                imported_models["OpenAIFineTuningJobResponseBody"] = (
+                    OpenAIFineTuningJobResponseBody
+                )
+            return imported_models["OpenAIFineTuningJobResponseBody"](
+                **response
+            )
+
+        # cancel fine-tuning
+        # TODO: need verification
+        if endpoint == "fine_tuning/jobs/{fine_tuning_job_id}/cancel":
+            if "OpenAIFineTuningJobResponseBody" not in imported_models:
+                from .fine_tuning.fine_tuning_job_models import (
+                    OpenAIFineTuningJobResponseBody,
+                )
+
+                imported_models["OpenAIFineTuningJobResponseBody"] = (
+                    OpenAIFineTuningJobResponseBody
+                )
+            return imported_models["OpenAIFineTuningJobResponseBody"](
+                **response
+            )
+
+    # Batch
+    elif "batches" in endpoint:
+        if endpoint == "batches" and method == "GET":
+            # list batch
+            if "OpenAIListBatchResponseBody" not in imported_models:
+                from .batch.list_batch import OpenAIListBatchResponseBody
+
+                imported_models["OpenAIListBatchResponseBody"] = (
+                    OpenAIListBatchResponseBody
+                )
+            return imported_models["OpenAIListBatchResponseBody"](**response)
+        else:
+            # other batch endpoints
+            if "OpenAIBatchResponseBody" not in imported_models:
+                from .batch.batch_models import OpenAIBatchResponseBody
+
+                imported_models["OpenAIBatchResponseBody"] = (
+                    OpenAIBatchResponseBody
+                )
+            return imported_models["OpenAIBatchResponseBody"](**response)
+
+    # Files
+    elif "files" in endpoint:
+        # upload file
+        if endpoint == "files" and method == "POST":
+            if "OpenAIFileResponseBody" not in imported_models:
+                from .files.file_models import OpenAIFileResponseBody
+
+                imported_models["OpenAIFileResponseBody"] = (
+                    OpenAIFileResponseBody
+                )
+            return imported_models["OpenAIFileResponseBody"](**response)
+
+        # list files
+        if endpoint == "files" and method == "GET":
+            if "OpenAIListFilesResponseBody" not in imported_models:
+                from .files.list_files import OpenAIListFilesResponseBody
+
+                imported_models["OpenAIListFilesResponseBody"] = (
+                    OpenAIListFilesResponseBody
+                )
+            return imported_models["OpenAIListFilesResponseBody"](**response)
+
+        # retrieve file
+        if endpoint == "files/{file_id}" and method == "GET":
+            if "OpenAIFileResponseBody" not in imported_models:
+                from .files.file_models import OpenAIFileResponseBody
+
+                imported_models["OpenAIFileResponseBody"] = (
+                    OpenAIFileResponseBody
+                )
+            return imported_models["OpenAIFileResponseBody"](**response)
+
+        # delete file
+        if endpoint == "files/{file_id}" and method == "DELETE":
+            if "OpenAIDeleteFileResponseBody" not in imported_models:
+                from .files.delete_file import OpenAIDeleteFileResponseBody
+
+                imported_models["OpenAIDeleteFileResponseBody"] = (
+                    OpenAIDeleteFileResponseBody
+                )
+            return imported_models["OpenAIDeleteFileResponseBody"](**response)
+
+        # retrieve file content
+        if endpoint == "files/{file_id}/content":
+            return response
+
+    # Uploads
+    if "uploads" in endpoint:
+        if endpoint == "uploads/{upload_id}/parts":
+            # add upload part
+            if "OpenAIUploadPartResponseBody" not in imported_models:
+                from .uploads.uploads_models import (
+                    OpenAIUploadPartResponseBody,
+                )
+
+                imported_models["OpenAIUploadPartResponseBody"] = (
+                    OpenAIUploadPartResponseBody
+                )
+            return imported_models["OpenAIUploadPartResponseBody"](**response)
+        else:
+            # other upload endpoints
+            if "OpenAIUploadResponseBody" not in imported_models:
+                from .uploads.uploads_models import OpenAIUploadResponseBody
+
+                imported_models["OpenAIUploadResponseBody"] = (
+                    OpenAIUploadResponseBody
+                )
+            return imported_models["OpenAIUploadResponseBody"](**response)
+
+    # Images
+    if "images" in endpoint:
+        if "OpenAIImageResponseBody" not in imported_models:
+            from .images.response_body import OpenAIImageResponseBody
+
+            imported_models["OpenAIImageResponseBody"] = (
+                OpenAIImageResponseBody
+            )
+        return imported_models["OpenAIImageResponseBody"](**response)
+
+    if "models" in endpoint:
+        # list models
+        if endpoint == "models":
+            if "OpenAIListModelResponseBody" not in imported_models:
+                from .models.models_models import OpenAIListModelResponseBody
+
+                imported_models["OpenAIListModelResponseBody"] = (
+                    OpenAIListModelResponseBody
+                )
+            return imported_models["OpenAIListModelResponseBody"](**response)
+
+        # retrieve model
+        if endpoint == "models/{model}" and method == "GET":
+            if "OpenAIModelResponseBody" not in imported_models:
+                from .models.models_models import OpenAIModelResponseBody
+
+                imported_models["OpenAIModelResponseBody"] = (
+                    OpenAIModelResponseBody
+                )
+            return imported_models["OpenAIModelResponseBody"](**response)
+
+        # delete a fine-tuned model
+        if endpoint == "models/{model}" and method == "DELETE":
+            if "OpenAIDeleteFineTunedModelResponseBody" not in imported_models:
+                from .models.delete_fine_tuned_model import (
+                    OpenAIDeleteFineTunedModelResponseBody,
+                )
+
+                imported_models["OpenAIDeleteFineTunedModelResponseBody"] = (
+                    OpenAIDeleteFineTunedModelResponseBody
+                )
+            return imported_models["OpenAIDeleteFineTunedModelResponseBody"](
+                **response
+            )
+
+    # Moderation
+    if endpoint == "moderations":
+        if "OpenAIModerationResponseBody" not in imported_models:
+            from .moderations.response_body import OpenAIModerationResponseBody
+
+            imported_models["OpenAIModerationResponseBody"] = (
+                OpenAIModerationResponseBody
+            )
+        return imported_models["OpenAIModerationResponseBody"](**response)
+
+    raise ValueError(
+        "There is no standard response model for the provided request and response"
+    )

lionagi/integrations/openai_/api_endpoints/models/__init__.py

@@ -0,0 +1,7 @@
+from .delete_fine_tuned_model import OpenAIDeleteFineTunedModelPathParam
+from .retrieve_model import OpenAIRetrieveModelPathParam
+
+__all__ = [
+    "OpenAIRetrieveModelPathParam",
+    "OpenAIDeleteFineTunedModelPathParam",
+]

lionagi/integrations/openai_/api_endpoints/models/delete_fine_tuned_model.py

@@ -0,0 +1,17 @@
+from pydantic import Field
+
+from ..data_models import OpenAIEndpointPathParam, OpenAIEndpointResponseBody
+
+
+class OpenAIDeleteFineTunedModelPathParam(OpenAIEndpointPathParam):
+    model: str = Field(description="The model to delete.")
+
+
+class OpenAIDeleteFineTunedModelResponseBody(OpenAIEndpointResponseBody):
+    id: str = Field(
+        description="The file identifier, which can be referenced in the API endpoints.",
+    )
+
+    object: str = Field(description="The object type, which is always model.")
+
+    deleted: bool = Field(description="The deletion status")

lionagi/integrations/openai_/api_endpoints/models/models_models.py

@@ -0,0 +1,31 @@
+from typing import List, Literal
+
+from pydantic import Field
+
+from ..data_models import OpenAIEndpointResponseBody
+
+
+class OpenAIModelResponseBody(OpenAIEndpointResponseBody):
+    id: str = Field(
+        description="The model identifier, which can be referenced in the API endpoints.",
+    )
+
+    created: int = Field(
+        description="The Unix timestamp (in seconds) when the model was created."
+    )
+
+    object: Literal["model"] = Field(
+        description="The object type, which is always 'model'."
+    )
+
+    owned_by: str = Field(description="The organization that owns the model.")
+
+
+class OpenAIListModelResponseBody(OpenAIEndpointResponseBody):
+    object: Literal["list"] = Field(
+        description="The object type, which is always 'list'."
+    )
+
+    data: list[OpenAIModelResponseBody] = Field(
+        description="The list of model objects."
+    )

lionagi/integrations/openai_/api_endpoints/models/retrieve_model.py

@@ -0,0 +1,9 @@
+from pydantic import Field
+
+from ..data_models import OpenAIEndpointPathParam
+
+
+class OpenAIRetrieveModelPathParam(OpenAIEndpointPathParam):
+    model: str = Field(
+        description="The ID of the model to use for this request."
+    )