qwak-core 0.1.37__py3-none-any.whl → 0.5.19__py3-none-any.whl

qwak/clients/logging_client/client.py

@@ -12,10 +12,10 @@ from _qwak_proto.qwak.logging.log_source_pb2 import (
     ModelRuntimeSource,
     RemoteBuildSource,
 )
-from grpc import RpcError
 from qwak.clients.administration.eco_system.client import EcosystemClient
 from qwak.exceptions import QwakException
 from qwak.inner.tool.grpc.grpc_tools import create_grpc_channel
+from qwak.inner.tool.grpc.grpc_try_wrapping import grpc_try_catch_wrapper
 
 
 class LoggingClient:
@@ -119,6 +119,7 @@ class LoggingClient:
         except QwakException as e:
             raise QwakException(f"Failed to fetch execution logs, error is [{e}]")
 
+    @grpc_try_catch_wrapper("Failed to read logs request")
     def read_logs(
         self,
         source,
@@ -127,21 +128,15 @@ class LoggingClient:
         max_number_of_results,
         log_text_filter,
     ):
-        try:
-            response = self._logging_service.ReadLogs(
-                ReadLogsRequest(
-                    source=source,
-                    before_offset=before_offset,
-                    after_offset=after_offset,
-                    search_filter=SearchFilter(
-                        log_text_filter=LogText(contains=log_text_filter)
-                    ),
-                    max_number_of_results=max_number_of_results,
-                )
-            )
-            return response
-        except RpcError as e:
-            raise QwakException(
-                f"Failed grpc read logs request, grpc error is "
-                f"[{e.details() if e.details() else e.code()}]"
+        response = self._logging_service.ReadLogs(
+            ReadLogsRequest(
+                source=source,
+                before_offset=before_offset,
+                after_offset=after_offset,
+                search_filter=SearchFilter(
+                    log_text_filter=LogText(contains=log_text_filter)
+                ),
+                max_number_of_results=max_number_of_results,
             )
+        )
+        return response

qwak/clients/model_management/client.py

@@ -53,7 +53,12 @@ class ModelsManagementClient:
         model = self.get_model(model_id)
         return model.uuid
 
-    def create_model(self, project_id, model_name, model_description):
+    def create_model(
+        self,
+        project_id,
+        model_name,
+        model_description,
+    ):
         try:
             return self._models_management_service.CreateModel(
                 CreateModelRequest(
@@ -62,7 +67,7 @@ class ModelsManagementClient:
                         display_name=model_name,
                         project_id=project_id,
                         model_description=model_description,
-                    )
+                    ),
                 )
             )
 

qwak/clients/project/client.py

@@ -27,11 +27,16 @@ class ProjectsManagementClient:
         except grpc.RpcError as e:
             raise QwakException(f"Failed to list projects, error is {e.details()}")
 
-    def create_project(self, project_name, project_description):
+    def create_project(
+        self,
+        project_name,
+        project_description,
+    ):
         try:
             return self._projects_management_service.CreateProject(
                 CreateProjectRequest(
-                    project_name=project_name, project_description=project_description
+                    project_name=project_name,
+                    project_description=project_description,
                 )
             )
 

qwak/clients/prompt_manager/model_descriptor_mapper.py

@@ -0,0 +1,183 @@
+from typing import List, Optional, Union
+
+from _qwak_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
+    OpenAICapabilities as ProtoOpenAICapabilities,
+    OpenAIChatAPI as ProtoOpenAIChatAPI,
+    OpenAIChatModelParams as ProtoOpenAIChatModelParams,
+    OpenAIModelDescriptor as ProtoOpenAIModelDescriptor,
+    ToolChoice as ProtoToolChoice,
+    Tools as ProtoTools,
+)
+from _qwak_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    PromptModelDescriptor as ProtoPromptModelDescriptor,
+    PromptOpenAIProvider as ProtoPromptOpenAIProvider,
+)
+from google.protobuf import json_format
+from google.protobuf.struct_pb2 import ListValue, Struct
+from qwak.exceptions import QwakException
+from qwak.llmops.generation.chat.openai.types.chat.chat_completion_named_tool_choice_param import (
+    ChatCompletionNamedToolChoiceParam,
+)
+from qwak.llmops.generation.chat.openai.types.chat.chat_completion_tool_param import (
+    ChatCompletionToolParam,
+)
+from qwak.llmops.model.descriptor import ModelDescriptor, OpenAIChat
+
+
+class ModelDescriptorMapper:
+    @staticmethod
+    def _from_tool_choice(
+        openai_chat_params: ProtoOpenAIChatModelParams,
+    ) -> Optional[Union[str, ChatCompletionNamedToolChoiceParam]]:
+        _tool_choice: Optional[Union[str, ChatCompletionNamedToolChoiceParam]] = None
+        if openai_chat_params.HasField("tool_choice"):
+            if openai_chat_params.tool_choice.WhichOneof("value_type") == "json":
+                _tool_choice = json_format.MessageToDict(
+                    openai_chat_params.tool_choice.json
+                )
+            elif openai_chat_params.tool_choice.WhichOneof("value_type") == "literal":
+                _tool_choice = openai_chat_params.tool_choice.literal
+        return _tool_choice
+
+    @staticmethod
+    def from_openai_chat_capability(
+        model_id: str, openai_chat_params: ProtoOpenAIChatModelParams
+    ) -> OpenAIChat:
+        p = openai_chat_params
+        _tool_choice: Union[str, ChatCompletionNamedToolChoiceParam] = (
+            ModelDescriptorMapper._from_tool_choice(
+                openai_chat_params=openai_chat_params
+            )
+        )
+        _tools: List[ChatCompletionToolParam] = []
+
+        if p.HasField("tools_spec"):
+            for tool in p.tools_spec.tools:
+                _tools.append(json_format.MessageToDict(tool))
+
+        return OpenAIChat(
+            model_id=model_id,
+            frequency_penalty=(
+                p.frequency_penalty if p.HasField("frequency_penalty") else None
+            ),
+            logit_bias=(
+                {k: int(v) for k, v in p.logit_bias.items()}
+                if p.HasField("logit_bias")
+                else None
+            ),
+            logprobs=p.logprobs if p.HasField("logprobs") else None,
+            max_tokens=p.max_tokens if p.HasField("max_tokens") else None,
+            n=p.n if p.HasField("n") else None,
+            presence_penalty=(
+                p.presence_penalty if p.HasField("presence_penalty") else None
+            ),
+            response_format=(
+                p.response_format if p.HasField("response_format") else None
+            ),  # noqa
+            seed=p.seed if p.HasField("seed") else None,
+            stop=[_ for _ in p.stop] if p.HasField("stop") else None,
+            temperature=p.temperature if p.HasField("temperature") else None,
+            top_p=p.top_p if p.HasField("top_p") else None,
+            top_logprobs=p.top_logprobs if p.HasField("top_logprobs") else None,
+            user=p.user if p.HasField("user") else None,
+            tool_choice=_tool_choice if p.HasField("tool_choice") else None,
+            tools=_tools if p.HasField("tools_spec") else None,
+        )
+
+    @staticmethod
+    def from_prompt_openai_provider(
+        open_ai_provider: ProtoPromptOpenAIProvider,
+    ) -> ModelDescriptor:
+        descriptor: ProtoOpenAIModelDescriptor = (
+            open_ai_provider.open_ai_model_descriptor
+        )
+        model_id: str = descriptor.model_id
+
+        if descriptor.capabilities.WhichOneof("optional_chat"):
+            return ModelDescriptorMapper.from_openai_chat_capability(
+                model_id=model_id,
+                openai_chat_params=descriptor.capabilities.chat_api.chat_params,
+            )
+        else:
+            raise QwakException(
+                f"Got unsupported openai capability: {repr(open_ai_provider)}"
+            )
+
+    @staticmethod
+    def from_prompt_model_descriptor(
+        model_descriptor: ProtoPromptModelDescriptor,
+    ) -> ModelDescriptor:
+        if model_descriptor.WhichOneof("model_provider") == "open_ai_provider":
+            return ModelDescriptorMapper.from_prompt_openai_provider(
+                model_descriptor.open_ai_provider
+            )
+        else:
+            raise QwakException(
+                f"Got unsupported model descriptor: {repr(model_descriptor)}"
+            )
+
+    @staticmethod
+    def to_openai_chat(model_descriptor: OpenAIChat) -> ProtoOpenAIModelDescriptor:
+        d: OpenAIChat = model_descriptor
+        logit_bias_struct = Struct()
+
+        logit_bias_struct.update(d.logit_bias) if d.logit_bias else None
+
+        stop_list_value = ListValue()
+        stop_list_value.extend(d.stop) if d.stop else None
+        tool_choice_proto: ProtoToolChoice
+
+        if isinstance(d.tool_choice, str):
+            tool_choice_proto = ProtoToolChoice(literal=d.tool_choice)
+        elif d.tool_choice is not None:
+            tool_choice_struct = Struct()
+            tool_choice_struct.update(d.tool_choice)
+            tool_choice_proto = ProtoToolChoice(json=tool_choice_struct)
+
+        tools_structs = []
+        if d.tools:
+            for tool in d.tools:
+                s = Struct()
+                s.update(tool)
+                tools_structs.append(s)
+
+        tools_proto = ProtoTools(tools=tools_structs)
+
+        model_capabilities = ProtoOpenAICapabilities(
+            chat_api=ProtoOpenAIChatAPI(
+                chat_params=ProtoOpenAIChatModelParams(
+                    frequency_penalty=d.frequency_penalty,
+                    logit_bias=logit_bias_struct if d.logit_bias else None,
+                    logprobs=d.logprobs,
+                    max_tokens=d.max_tokens,
+                    n=d.n,
+                    presence_penalty=d.presence_penalty,
+                    response_format=(
+                        d.response_format if d.response_format else None
+                    ),  # noqa
+                    seed=d.seed,
+                    stop=stop_list_value if d.stop else None,
+                    temperature=d.temperature,
+                    tool_choice=tool_choice_proto if d.tool_choice else None,
+                    tools_spec=tools_proto if d.tools else None,
+                    top_logprobs=d.top_logprobs,
+                    top_p=d.top_p,
+                    user=d.user,
+                )
+            )
+        )
+
+        return ProtoOpenAIModelDescriptor(
+            model_id=model_descriptor.model_id, capabilities=model_capabilities
+        )
+
+    @staticmethod
+    def to_model_descriptor(
+        model_descriptor: ModelDescriptor,
+    ) -> Union[ProtoOpenAIModelDescriptor]:
+        if isinstance(model_descriptor, OpenAIChat):
+            return ModelDescriptorMapper.to_openai_chat(model_descriptor)
+
+        raise QwakException(
+            f"Got unsupported model descriptor: {repr(model_descriptor)}"
+        )

qwak/clients/prompt_manager/prompt_manager_client.py

@@ -0,0 +1,167 @@
+import grpc
+from _qwak_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2 import (
+    CreatePromptRequest as ProtoCreatePromptRequest,
+    CreatePromptResponse as ProtoCreatePromptResponse,
+    CreatePromptVersionRequest as ProtoCreatePromptVersionRequest,
+    CreatePromptVersionResponse as ProtoCreatePromptVersionResponse,
+    DeletePromptRequest as ProtoDeletePromptRequest,
+    DeletePromptVersionRequest as ProtoDeletePromptVersionRequest,
+    GetPromptByNameRequest as ProtoGetPromptByNameRequest,
+    GetPromptByNameResponse as ProtoGetPromptByNameResponse,
+    GetPromptVersionByPromptNameRequest as ProtoGetPromptVersionByPromptNameRequest,
+    GetPromptVersionByPromptNameResponse as ProtoGetPromptVersionByPromptNameResponse,
+    SetDefaultPromptVersionRequest as ProtoSetDefaultPromptVersionRequest,
+)
+from _qwak_proto.qwak.prompt.v1.prompt.prompt_manager_service_pb2_grpc import (
+    PromptManagerServiceStub,
+)
+from _qwak_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    Prompt as ProtoPrompt,
+    PromptSpec as ProtoPromptSpec,
+    PromptVersion as ProtoPromptVersion,
+    PromptVersionSpec as ProtoPromptVersionSpec,
+)
+from dependency_injector.wiring import Provide, inject
+from qwak.exceptions import QwakException
+from qwak.inner.di_configuration import QwakContainer
+
+
+class PromptManagerClient:
+    @inject
+    def __init__(self, grpc_channel=Provide[QwakContainer.core_grpc_channel]):
+        self._grpc_client: PromptManagerServiceStub = PromptManagerServiceStub(
+            grpc_channel
+        )
+
+    def create_prompt(
+        self,
+        name: str,
+        prompt_description: str,
+        version_spec: ProtoPromptVersionSpec,
+    ) -> ProtoPrompt:
+        request = ProtoCreatePromptRequest(
+            prompt_name=name,
+            prompt_spec=ProtoPromptSpec(description=prompt_description),
+            prompt_version_spec=version_spec,
+        )
+        try:
+            response: ProtoCreatePromptResponse = self._grpc_client.CreatePrompt(
+                request
+            )
+            return response.prompt
+        except grpc.RpcError as error:
+            call: grpc.Call = error  # noqa
+            if call.code() == grpc.StatusCode.ALREADY_EXISTS:
+                raise QwakException(f"Prompt with name: {name} already exists")
+            elif call.code() == grpc.StatusCode.INVALID_ARGUMENT:
+                raise QwakException(
+                    f"Got an illegal prompt specification: {call.details()}"
+                )
+            else:
+                raise QwakException(f"Internal Error: {call.details()}")
+
+    def create_prompt_version(
+        self,
+        name: str,
+        version_spec: ProtoPromptVersionSpec,
+        set_default: bool,
+    ) -> ProtoPromptVersion:
+        request = ProtoCreatePromptVersionRequest(
+            prompt_name=name, prompt_version_spec=version_spec, set_default=set_default
+        )
+        try:
+            response: ProtoCreatePromptVersionResponse = (
+                self._grpc_client.CreatePromptVersion(request)
+            )
+            return response.prompt_version
+        except grpc.RpcError as error:
+            call: grpc.Call = error  # noqa
+            if call.code() == grpc.StatusCode.NOT_FOUND:
+                raise QwakException(
+                    f"Can not update prompt: '{name}', prompt was not found"
+                )
+            elif call.code() == grpc.StatusCode.INVALID_ARGUMENT:
+                raise QwakException(
+                    f"Got an illegal prompt specification: {call.details()}"
+                )
+            else:
+                raise QwakException(f"Internal Error: {call.details()}")
+
+    def delete_prompt(self, name: str):
+        try:
+            self._grpc_client.DeletePrompt(ProtoDeletePromptRequest(prompt_name=name))
+        except grpc.RpcError as error:
+            call: grpc.Call = error  # noqa
+            if call.code() == grpc.StatusCode.NOT_FOUND:
+                raise QwakException(f"Prompt named '{name}' was not found")
+            else:
+                raise QwakException(f"Internal Error: {call.details()}")
+
+    def delete_prompt_version(self, name: str, version: int):
+        try:
+            self._grpc_client.DeletePromptVersion(
+                ProtoDeletePromptVersionRequest(
+                    prompt_name=name, version_number=version
+                )
+            )
+        except grpc.RpcError as error:
+            call: grpc.Call = error  # noqa
+            if call.code() == grpc.StatusCode.NOT_FOUND:
+                raise QwakException(str(call.details()))
+            elif call.code() == grpc.StatusCode.FAILED_PRECONDITION:
+                raise QwakException(
+                    f"Cannot delete the default version '{version}' of a prompt '{name}',"
+                    f" please set another version as the default to delete this version."
+                )
+            else:
+                raise QwakException(f"Internal Error: {call.details()}")
+
+    def get_prompt_by_name(self, name: str) -> ProtoPrompt:
+        """
+        Get prompt's default version
+        """
+        try:
+            response: ProtoGetPromptByNameResponse = self._grpc_client.GetPromptByName(
+                ProtoGetPromptByNameRequest(prompt_name=name)
+            )
+            return response.prompt
+        except grpc.RpcError as error:
+            call: grpc.Call = error  # noqa
+            if call.code() == grpc.StatusCode.NOT_FOUND:
+                raise QwakException(str(call.details()))
+            else:
+                raise QwakException(f"Internal Error: {call.details()}")
+
+    def get_prompt_version_by_name(self, name: str, version: int) -> ProtoPromptVersion:
+        """
+        Get prompt specific version
+        """
+        try:
+            response: ProtoGetPromptVersionByPromptNameResponse = (
+                self._grpc_client.GetPromptVersionByPromptName(
+                    ProtoGetPromptVersionByPromptNameRequest(
+                        prompt_name=name, version_number=version
+                    )
+                )
+            )
+            return response.prompt_version
+        except grpc.RpcError as error:
+            call: grpc.Call = error  # noqa
+            if call.code() == grpc.StatusCode.NOT_FOUND:
+                raise QwakException(str(call.details()))
+            else:
+                raise QwakException(f"Internal Error: {call.details()}")
+
+    def set_default_prompt_version(self, name: str, version: int):
+        try:
+            self._grpc_client.SetDefaultPromptVersion(
+                ProtoSetDefaultPromptVersionRequest(
+                    prompt_name=name, version_number=version
+                )
+            )
+        except grpc.RpcError as error:
+            call: grpc.Call = error  # noqa
+            if call.code() == grpc.StatusCode.NOT_FOUND:
+                raise QwakException(str(call.details()))
+            else:
+                raise QwakException(f"Internal Error: {call.details()}")

qwak/clients/prompt_manager/prompt_proto_mapper.py

@@ -0,0 +1,236 @@
+from typing import List, Optional
+
+from _qwak_proto.qwak.model_descriptor.open_ai_descriptor_pb2 import (
+    OpenAIModelDescriptor as ProtoOpenAIModelDescriptor,
+)
+from _qwak_proto.qwak.prompt.v1.prompt.prompt_pb2 import (
+    AIPromptMessageRole as ProtoAIPromptMessageRole,
+    ChatMessage as ProtoChatMessage,
+    ChatMessageTemplate as ProtoChatMessageTemplate,
+    ChatPromptTemplate as ProtoChatPromptTemplate,
+    HumanPromptMessageRole as ProtoHumanPromptMessageRole,
+    PromptMessageRole as ProtoPromptMessageRole,
+    PromptModelDescriptor as ProtoPromptModelDescriptor,
+    PromptOpenAIProvider as ProtoPromptOpenAIProvider,
+    PromptTemplate as ProtoPromptTemplate,
+    PromptVersionDefinition as ProtoPromptVersionDefinition,
+    PromptVersionSpec as ProtoPromptVersionSpec,
+    SystemPromptMessageRole as ProtoSystemPromptMessageRole,
+    TextTemplate as ProtoTextTemplate,
+)
+from qwak.clients.prompt_manager.model_descriptor_mapper import ModelDescriptorMapper
+from qwak.exceptions import QwakException
+from qwak.llmops.model.descriptor import ChatModelDescriptor, ModelDescriptor
+from qwak.llmops.prompt.base import BasePrompt, ChatPrompt, RegisteredPrompt
+from qwak.llmops.prompt.chat.message import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from qwak.llmops.prompt.chat.template import (
+    AIMessagePromptTemplate,
+    BaseStringMessagePromptTemplate,
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    SystemMessagePromptTemplate,
+)
+from qwak.llmops.prompt.template import BasePromptTemplate
+
+
+class PromptProtoMapper:
+    @staticmethod
+    def from_chat_prompt_template(
+        chat_prompt_template: ProtoChatPromptTemplate,
+    ) -> ChatPromptTemplate:
+        messages: List[BaseStringMessagePromptTemplate] = []
+        for chat_message in chat_prompt_template.chat_messages:
+            template: str = chat_message.template.text_template.template
+            role_type: str = chat_message.role.WhichOneof("role")
+            if role_type == "human_role":
+                messages.append(HumanMessagePromptTemplate(template=template))
+            elif role_type == "system_role":
+                messages.append(SystemMessagePromptTemplate(template=template))
+            elif role_type == "ai_role":
+                messages.append(AIMessagePromptTemplate(template=template))
+            else:
+                raise QwakException(
+                    f"Got unsupported chat message type: {repr(chat_message)}"
+                )
+
+        return ChatPromptTemplate(messages=messages)
+
+    @staticmethod
+    def from_prompt_template(
+        prompt_template: ProtoPromptTemplate,
+    ) -> BasePromptTemplate:
+        if prompt_template.WhichOneof("type") == "chat_prompt_template":
+            return PromptProtoMapper.from_chat_prompt_template(
+                chat_prompt_template=prompt_template.chat_prompt_template
+            )
+        else:
+            raise QwakException(
+                f"Got unsupported prompt template: {repr(prompt_template)}"
+            )
+
+    @staticmethod
+    def to_prompt_model_descriptor(
+        model_descriptor: ModelDescriptor,
+    ) -> ProtoPromptModelDescriptor:
+        proto_model_descriptor = ModelDescriptorMapper.to_model_descriptor(
+            model_descriptor=model_descriptor
+        )
+        if isinstance(proto_model_descriptor, ProtoOpenAIModelDescriptor):
+            return ProtoPromptModelDescriptor(
+                open_ai_provider=ProtoPromptOpenAIProvider(
+                    open_ai_model_descriptor=proto_model_descriptor
+                )
+            )
+
+        raise QwakException(
+            f"Got unsupported model descriptor: {repr(model_descriptor)}"
+        )
+
+    @staticmethod
+    def _prompt_template_to_chat_message(
+        msg: BaseStringMessagePromptTemplate,
+    ) -> ProtoChatMessage:
+        role: ProtoPromptMessageRole
+        text_template: str = msg.template.template
+
+        if isinstance(msg, SystemMessagePromptTemplate):
+            role = ProtoPromptMessageRole(system_role=ProtoSystemPromptMessageRole())
+        elif isinstance(msg, HumanMessagePromptTemplate):
+            role = ProtoPromptMessageRole(human_role=ProtoHumanPromptMessageRole())
+        elif isinstance(msg, AIMessagePromptTemplate):
+            role = ProtoPromptMessageRole(ai_role=ProtoAIPromptMessageRole())
+        else:
+            raise QwakException(f"Got unsupported prompt template role: {repr(msg)}")
+
+        return ProtoChatMessage(
+            role=role,
+            template=ProtoChatMessageTemplate(
+                text_template=ProtoTextTemplate(template=text_template)
+            ),
+        )
+
+    @staticmethod
+    def _base_message_to_chat_message(msg: BaseMessage) -> ProtoChatMessage:
+        role: ProtoPromptMessageRole
+        text_template: str = msg.content
+
+        if isinstance(msg, AIMessage):
+            role = ProtoPromptMessageRole(ai_role=ProtoAIPromptMessageRole())
+        elif isinstance(msg, HumanMessage):
+            role = ProtoPromptMessageRole(human_role=ProtoHumanPromptMessageRole())
+        elif isinstance(msg, SystemMessage):
+            role = ProtoPromptMessageRole(system_role=ProtoSystemPromptMessageRole())
+        else:
+            raise QwakException(f"Got unsupported prompt template role: {repr(msg)}")
+
+        return ProtoChatMessage(
+            role=role,
+            template=ProtoChatMessageTemplate(
+                text_template=ProtoTextTemplate(template=text_template)
+            ),
+        )
+
+    @staticmethod
+    def to_proto_chat_prompt_template(
+        prompt_template: ChatPromptTemplate,
+    ) -> ProtoPromptTemplate:
+        chat_messages: List[ProtoChatMessage] = []
+
+        for msg in prompt_template.messages:
+            if isinstance(msg, BaseStringMessagePromptTemplate):
+                chat_messages.append(
+                    PromptProtoMapper._prompt_template_to_chat_message(msg=msg)
+                )
+            elif isinstance(msg, BaseMessage):
+                chat_messages.append(
+                    PromptProtoMapper._base_message_to_chat_message(msg=msg)
+                )
+
+        return ProtoPromptTemplate(
+            chat_prompt_template=ProtoChatPromptTemplate(chat_messages=chat_messages)
+        )
+
+    @staticmethod
+    def to_proto_prompt_template(
+        prompt_template: BasePromptTemplate,
+    ) -> ProtoPromptTemplate:
+        if isinstance(prompt_template, ChatPromptTemplate):
+            return PromptProtoMapper.to_proto_chat_prompt_template(
+                prompt_template=prompt_template
+            )
+
+        raise QwakException(f"Got unsupported prompt template: {repr(prompt_template)}")
+
+    @staticmethod
+    def to_prompt_version_spec(
+        version_description: str,
+        prompt_template: BasePromptTemplate,
+        model_descriptor: Optional[ModelDescriptor],
+    ) -> ProtoPromptVersionSpec:
+        prompt_model_descriptor: Optional[ProtoPromptModelDescriptor] = None
+
+        if model_descriptor:
+            prompt_model_descriptor: ProtoPromptModelDescriptor = (
+                PromptProtoMapper.to_prompt_model_descriptor(
+                    model_descriptor=model_descriptor
+                )
+            )
+
+        proto_prompt_template: ProtoPromptTemplate = (
+            PromptProtoMapper.to_proto_prompt_template(prompt_template=prompt_template)
+        )
+
+        return ProtoPromptVersionSpec(
+            description=version_description,
+            prompt_template=proto_prompt_template,
+            model_descriptor=prompt_model_descriptor,
+        )
+
+    @staticmethod
+    def from_prompt_version_definition(
+        prompt_version_def: ProtoPromptVersionDefinition,
+    ) -> BasePrompt:
+        model_descriptor: Optional[ModelDescriptor] = None
+        prompt_template: ProtoPromptTemplate = (
+            prompt_version_def.version_spec.prompt_template
+        )
+        base_prompt_template: BasePromptTemplate = (
+            PromptProtoMapper.from_prompt_template(prompt_template)
+        )
+
+        if prompt_version_def.version_spec.HasField("model_descriptor"):
+            model_descriptor: ModelDescriptor = (
+                ModelDescriptorMapper.from_prompt_model_descriptor(
+                    model_descriptor=prompt_version_def.version_spec.model_descriptor
+                )
+            )
+
+        if isinstance(base_prompt_template, ChatPromptTemplate) and (
+            not model_descriptor or isinstance(model_descriptor, ChatModelDescriptor)
+        ):
+            return ChatPrompt(template=base_prompt_template, model=model_descriptor)
+
+    @staticmethod
+    def from_prompt(
+        name: str,
+        prompt_description: str,
+        version_description: str,
+        version: int,
+        target_default_version: bool,
+        prompt_version_definition: ProtoPromptVersionDefinition,
+    ) -> RegisteredPrompt:
+        return RegisteredPrompt(
+            name=name,
+            prompt_description=prompt_description,
+            version_description=version_description,
+            version=version,
+            _target_default_version=target_default_version,
+            prompt=PromptProtoMapper.from_prompt_version_definition(
+                prompt_version_def=prompt_version_definition
+            ),
+        )