freeplay 0.2.42__py3-none-any.whl → 0.3.0a2__py3-none-any.whl

freeplay/{thin/resources → resources}/prompts.py

@@ -4,15 +4,22 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Dict, Optional, List, Union, cast, Any
 
-from freeplay.completions import PromptTemplates, ChatMessage, PromptTemplateWithMetadata
 from freeplay.errors import FreeplayConfigurationError, FreeplayClientError
-from freeplay.flavors import Flavor
 from freeplay.llm_parameters import LLMParameters
 from freeplay.model import InputVariables
-from freeplay.support import CallSupport, PromptTemplate, PromptTemplateMetadata
+from freeplay.support import PromptTemplate, PromptTemplates, PromptTemplateMetadata
+from freeplay.support import CallSupport
 from freeplay.utils import bind_template_variables
 
 
+class MissingFlavorError(FreeplayConfigurationError):
+    def __init__(self, flavor_name: str):
+        super().__init__(
+            f'Configured flavor ({flavor_name}) not found in SDK. Please update your SDK version or configure '
+            'a different model in the Freeplay UI.'
+        )
+
+
 # SDK-Exposed Classes
 @dataclass
 class PromptInfo:
@@ -54,18 +61,40 @@ class BoundPrompt:
         self.prompt_info = prompt_info
         self.messages = messages
 
+    @staticmethod
+    def __to_anthropic_role(role: str) -> str:
+        if role == 'assistant' or role == 'Assistant':
+            return 'Assistant'
+        else:
+            # Anthropic does not support system role for now.
+            return 'Human'
+
+    @staticmethod
+    def __format_messages_for_flavor(flavor_name: str, messages: List[Dict[str, str]]) -> Union[
+        str, List[Dict[str, str]]]:
+        if flavor_name == 'azure_openai_chat' or flavor_name == 'openai_chat':
+            return messages
+        elif flavor_name == 'anthropic_chat':
+            formatted_messages = []
+            for message in messages:
+                role = BoundPrompt.__to_anthropic_role(message['role'])
+                formatted_messages.append(f"{role}: {message['content']}")
+            formatted_messages.append('Assistant:')
+
+            return "\n\n" + "\n\n".join(formatted_messages)
+        raise MissingFlavorError(flavor_name)
+
     def format(
             self,
             flavor_name: Optional[str] = None
     ) -> FormattedPrompt:
         final_flavor = flavor_name or self.prompt_info.flavor_name
-        flavor = Flavor.get_by_name(final_flavor)
-        llm_format = flavor.to_llm_syntax(cast(List[ChatMessage], self.messages))
+        llm_format = BoundPrompt.__format_messages_for_flavor(final_flavor, self.messages)
 
         return FormattedPrompt(
             self.prompt_info,
             self.messages,
-            cast(Union[str, List[Dict[str, str]]], llm_format)
+            llm_format,
         )
 
 
@@ -120,15 +149,7 @@ class FilesystemTemplateResolver(TemplateResolver):
         prompt_list = []
         for prompt_file_path in prompt_file_paths:
             json_dom = json.loads(prompt_file_path.read_text())
-
-            prompt_list.append(PromptTemplateWithMetadata(
-                prompt_template_id=json_dom.get('prompt_template_id'),
-                prompt_template_version_id=json_dom.get('prompt_template_version_id'),
-                name=json_dom.get('name'),
-                content=json_dom.get('content'),
-                flavor_name=json_dom.get('metadata').get('flavor_name'),
-                params=json_dom.get('metadata').get('params')
-            ))
+            prompt_list.append(self.__render_into_v2(json_dom))
 
         return PromptTemplates(prompt_list)
 
@@ -144,38 +165,59 @@ class FilesystemTemplateResolver(TemplateResolver):
             )
 
         json_dom = json.loads(expected_file.read_text())
+        return self.__render_into_v2(json_dom)
 
+    @staticmethod
+    def __render_into_v2(json_dom: Dict[str, Any]) -> PromptTemplate:
         format_version = json_dom.get('format_version')
 
         if format_version == 2:
-            raise NotImplementedError("Cannot yet handle new format bundled prompts")
-
-        flavor_name = json_dom.get('metadata').get('flavor_name')
-        flavor = Flavor.get_by_name(flavor_name)
-
-        params = json_dom.get('metadata').get('params')
-        model = params.pop('model') if 'model' in params else None
-
-        return PromptTemplate(
-            format_version=2,
-            prompt_template_id=json_dom.get('prompt_template_id'),
-            prompt_template_version_id=json_dom.get('prompt_template_version_id'),
-            prompt_template_name=json_dom.get('name'),
-            content=FilesystemTemplateResolver.__normalize_roles(json.loads(json_dom.get('content'))),  # type: ignore
-            metadata=PromptTemplateMetadata(
-                provider=flavor.provider,
-                flavor=flavor_name,
-                model=model,
-                params=params
+            metadata = json_dom['metadata']
+            flavor_name = metadata.get('flavor')
+            model = metadata.get('model')
+
+            return PromptTemplate(
+                format_version=2,
+                prompt_template_id=json_dom.get('prompt_template_id'),  # type: ignore
+                prompt_template_version_id=json_dom.get('prompt_template_version_id'),  # type: ignore
+                prompt_template_name=json_dom.get('prompt_template_name'),  # type: ignore
+                content=FilesystemTemplateResolver.__normalize_roles(json_dom['content']),
+                metadata=PromptTemplateMetadata(
+                    provider=FilesystemTemplateResolver.__flavor_to_provider(flavor_name),
+                    flavor=flavor_name,
+                    model=model,
+                    params=metadata.get('params'),
+                    provider_info=metadata.get('provider_info')
+                )
+            )
+        else:
+            metadata = json_dom['metadata']
+
+            flavor_name = metadata.get('flavor_name')
+            params = metadata.get('params')
+            model = params.pop('model') if 'model' in params else None
+
+            return PromptTemplate(
+                format_version=2,
+                prompt_template_id=json_dom.get('prompt_template_id'),  # type: ignore
+                prompt_template_version_id=json_dom.get('prompt_template_version_id'),  # type: ignore
+                prompt_template_name=json_dom.get('name'),  # type: ignore
+                content=FilesystemTemplateResolver.__normalize_roles(json.loads(str(json_dom['content']))),
+                metadata=PromptTemplateMetadata(
+                    provider=FilesystemTemplateResolver.__flavor_to_provider(flavor_name),
+                    flavor=flavor_name,
+                    model=model,
+                    params=params,
+                    provider_info=None
+                )
             )
-        )
 
     @staticmethod
-    def __normalize_roles(messages: List[ChatMessage]) -> List[ChatMessage]:
+    def __normalize_roles(messages: List[Dict[str, str]]) -> List[Dict[str, str]]:
         normalized = []
         for message in messages:
             role = FilesystemTemplateResolver.__role_translations.get(message['role']) or message['role']
-            normalized.append(ChatMessage(role=role, content=message['content']))
+            normalized.append({'role': role, 'content': message['content']})
         return normalized
 
     @staticmethod
@@ -200,6 +242,18 @@ class FilesystemTemplateResolver(TemplateResolver):
                 (project_id, environment)
             )
 
+    @staticmethod
+    def __flavor_to_provider(flavor: str) -> str:
+        flavor_provider = {
+            'azure_openai_chat': 'azure',
+            'anthropic_chat': 'anthropic',
+            'openai_chat': 'openai',
+        }
+        provider = flavor_provider.get(flavor)
+        if not provider:
+            raise MissingFlavorError(flavor)
+        return provider
+
 
 class APITemplateResolver(TemplateResolver):
 
@@ -209,7 +263,7 @@ class APITemplateResolver(TemplateResolver):
     def get_prompts(self, project_id: str, environment: str) -> PromptTemplates:
         return self.call_support.get_prompts(
             project_id=project_id,
-            tag=environment
+            environment=environment
         )
 
     def get_prompt(self, project_id: str, template_name: str, environment: str) -> PromptTemplate:
@@ -226,7 +280,7 @@ class Prompts:
         self.template_resolver = template_resolver
 
     def get_all(self, project_id: str, environment: str) -> PromptTemplates:
-        return self.call_support.get_prompts(project_id=project_id, tag=environment)
+        return self.call_support.get_prompts(project_id=project_id, environment=environment)
 
     def get(self, project_id: str, template_name: str, environment: str) -> TemplatePrompt:
         prompt = self.template_resolver.get_prompt(project_id, template_name, environment)
@@ -242,7 +296,9 @@ class Prompts:
             raise FreeplayConfigurationError(
                 "Flavor must be configured in the Freeplay UI. Unable to fulfill request.")
 
-        flavor = Flavor.get_by_name(prompt.metadata.flavor)
+        if not prompt.metadata.provider:
+            raise FreeplayConfigurationError(
+                "Provider must be configured in the Freeplay UI. Unable to fulfill request.")
 
         prompt_info = PromptInfo(
             prompt_template_id=prompt.prompt_template_id,
@@ -250,7 +306,7 @@ class Prompts:
             template_name=prompt.prompt_template_name,
             environment=environment,
             model_parameters=cast(LLMParameters, params) or LLMParameters({}),
-            provider=flavor.provider,
+            provider=prompt.metadata.provider,
             model=model,
             flavor_name=prompt.metadata.flavor,
             provider_info=prompt.metadata.provider_info

freeplay/{thin/resources → resources}/recordings.py

@@ -6,13 +6,12 @@ from typing import Dict, Optional, List
 from requests import HTTPError
 
 from freeplay import api_support
-from freeplay.completions import PromptTemplateWithMetadata, OpenAIFunctionCall
 from freeplay.errors import FreeplayClientError, FreeplayError
 from freeplay.llm_parameters import LLMParameters
-from freeplay.model import InputVariables
+from freeplay.model import InputVariables, OpenAIFunctionCall
+from freeplay.resources.prompts import PromptInfo
+from freeplay.resources.sessions import SessionInfo
 from freeplay.support import CallSupport
-from freeplay.thin.resources.prompts import PromptInfo
-from freeplay.thin.resources.sessions import SessionInfo
 
 logger = logging.getLogger(__name__)
 
@@ -79,19 +78,10 @@ class Recordings:
         completion = record_payload.all_messages[-1]
         history_as_string = json.dumps(record_payload.all_messages[0:-1])
 
-        template = PromptTemplateWithMetadata(
-            prompt_template_id=record_payload.prompt_info.prompt_template_id,
-            prompt_template_version_id=record_payload.prompt_info.prompt_template_version_id,
-            name=record_payload.prompt_info.template_name,
-            content=history_as_string,
-            flavor_name=record_payload.prompt_info.flavor_name,
-            params=record_payload.prompt_info.model_parameters
-        )
-
         record_api_payload = {
             "session_id": record_payload.session_info.session_id,
-            "project_version_id": template.prompt_template_version_id,
-            "prompt_template_id": template.prompt_template_id,
+            "prompt_template_id": record_payload.prompt_info.prompt_template_id,
+            "project_version_id": record_payload.prompt_info.prompt_template_version_id,
             "start_time": record_payload.call_info.start_time,
             "end_time": record_payload.call_info.end_time,
             "tag": record_payload.prompt_info.environment,

freeplay/{thin/resources → resources}/test_runs.py

@@ -2,8 +2,8 @@ from dataclasses import dataclass
 from typing import List, Optional
 
 from freeplay.model import InputVariables
+from freeplay.resources.recordings import TestRunInfo
 from freeplay.support import CallSupport
-from freeplay.thin.resources.recordings import TestRunInfo
 
 
 @dataclass

freeplay/support.py

@@ -1,42 +1,11 @@
-import json
-import time
-from copy import copy
 from dataclasses import dataclass
-from typing import Dict, Any, Optional, Union, List, Generator
-from uuid import uuid4
+from json import JSONEncoder
+from typing import Optional, Dict, Any, List, Union
 
 from freeplay import api_support
 from freeplay.api_support import try_decode
-from freeplay.completions import PromptTemplates, PromptTemplateWithMetadata, ChatMessage, ChatCompletionResponse, \
-    CompletionChunk, CompletionResponse
-from freeplay.errors import FreeplayConfigurationError, freeplay_response_error, FreeplayServerError
-from freeplay.flavors import ChatFlavor, Flavor, pick_flavor_from_config
-from freeplay.llm_parameters import LLMParameters
+from freeplay.errors import freeplay_response_error, FreeplayServerError
 from freeplay.model import InputVariables
-from freeplay.provider_config import ProviderConfig
-from freeplay.record import RecordProcessor, RecordCallFields
-
-JsonDom = Dict[str, Any]
-
-
-class TestCaseTestRunResponse:
-    def __init__(self, test_case: JsonDom):
-        self.id: str = test_case['id']
-        self.variables: InputVariables = test_case['variables']
-        self.output: Optional[str] = test_case.get('output')
-
-
-class TestRunResponse:
-    def __init__(
-            self,
-            test_run_id: str,
-            test_cases: List[JsonDom]
-    ):
-        self.test_cases = [
-            TestCaseTestRunResponse(test_case)
-            for test_case in test_cases
-        ]
-        self.test_run_id = test_run_id
 
 
 @dataclass
@@ -58,49 +27,59 @@ class PromptTemplate:
     format_version: int
 
 
+@dataclass
+class PromptTemplates:
+    prompt_templates: List[PromptTemplate]
+
+
+class PromptTemplateEncoder(JSONEncoder):
+    def default(self, prompt_template: PromptTemplate) -> Dict[str, Any]:
+        return prompt_template.__dict__
+
+
+class TestCaseTestRunResponse:
+    def __init__(self, test_case: Dict[str, Any]):
+        self.variables: InputVariables = test_case['variables']
+        self.id: str = test_case['id']
+        self.output: Optional[str] = test_case.get('output')
+
+
+class TestRunResponse:
+    def __init__(
+            self,
+            test_run_id: str,
+            test_cases: List[Dict[str, Any]]
+    ):
+        self.test_cases = [
+            TestCaseTestRunResponse(test_case)
+            for test_case in test_cases
+        ]
+        self.test_run_id = test_run_id
+
+
 class CallSupport:
     def __init__(
             self,
             freeplay_api_key: str,
-            api_base: str,
-            record_processor: RecordProcessor,
-            **kwargs: Any
+            api_base: str
     ) -> None:
         self.api_base = api_base
         self.freeplay_api_key = freeplay_api_key
-        self.client_params = LLMParameters(kwargs)
-        self.record_processor = record_processor
 
-    @staticmethod
-    def find_template_by_name(prompts: PromptTemplates, template_name: str) -> PromptTemplateWithMetadata:
-        templates = [t for t in prompts.templates if t.name == template_name]
-        if len(templates) == 0:
-            raise FreeplayConfigurationError(f'Could not find template with name "{template_name}"')
-        return templates[0]
+    def get_prompts(self, project_id: str, environment: str) -> PromptTemplates:
+        response = api_support.get_raw(
+            api_key=self.freeplay_api_key,
+            url=f'{self.api_base}/v2/projects/{project_id}/prompt-templates/all/{environment}'
+        )
 
-    @staticmethod
-    def create_session_id() -> str:
-        return str(uuid4())
+        if response.status_code != 200:
+            raise freeplay_response_error("Error getting prompt templates", response)
 
-    @staticmethod
-    def check_all_values_string_or_number(metadata: Optional[Dict[str, Union[str, int, float]]]) -> None:
-        if metadata:
-            for key, value in metadata.items():
-                if not isinstance(value, (str, int, float)):
-                    raise FreeplayConfigurationError(f"Invalid value for key {key}: Value must be a string or number.")
+        maybe_prompts = try_decode(PromptTemplates, response.content)
+        if maybe_prompts is None:
+            raise FreeplayServerError('Failed to parse prompt templates from server')
 
-    def update_customer_feedback(
-            self,
-            completion_id: str,
-            feedback: Dict[str, Union[bool, str, int, float]]
-    ) -> None:
-        response = api_support.put_raw(
-            self.freeplay_api_key,
-            f'{self.api_base}/v1/completion_feedback/{completion_id}',
-            feedback
-        )
-        if response.status_code != 201:
-            raise freeplay_response_error("Error updating customer feedback", response)
+        return maybe_prompts
 
     def get_prompt(self, project_id: str, template_name: str, environment: str) -> PromptTemplate:
         response = api_support.get_raw(
@@ -127,20 +106,18 @@ class CallSupport:
 
         return maybe_prompt
 
-    def get_prompts(self, project_id: str, tag: str) -> PromptTemplates:
-        response = api_support.get_raw(
-            api_key=self.freeplay_api_key,
-            url=f'{self.api_base}/projects/{project_id}/templates/all/{tag}'
+    def update_customer_feedback(
+            self,
+            completion_id: str,
+            feedback: Dict[str, Union[bool, str, int, float]]
+    ) -> None:
+        response = api_support.put_raw(
+            self.freeplay_api_key,
+            f'{self.api_base}/v1/completion_feedback/{completion_id}',
+            feedback
         )
-
-        if response.status_code != 200:
-            raise freeplay_response_error("Error getting prompt templates", response)
-
-        maybe_prompts = try_decode(PromptTemplates, response.content)
-        if maybe_prompts is None:
-            raise FreeplayServerError(f'Failed to parse prompt templates from server')
-
-        return maybe_prompts
+        if response.status_code != 201:
+            raise freeplay_response_error("Error updating customer feedback", response)
 
     def create_test_run(
             self,
@@ -162,220 +139,4 @@ class CallSupport:
 
         json_dom = response.json()
 
-        return TestRunResponse(json_dom['test_run_id'], json_dom['test_cases'])
-
-    # noinspection PyUnboundLocalVariable
-    def prepare_and_make_chat_call(
-            self,
-            session_id: str,
-            flavor: ChatFlavor,
-            provider_config: ProviderConfig,
-            tag: str,
-            target_template: PromptTemplateWithMetadata,
-            variables: InputVariables,
-            message_history: List[ChatMessage],
-            new_messages: Optional[List[ChatMessage]],
-            test_run_id: Optional[str] = None,
-            completion_parameters: Optional[LLMParameters] = None,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = None
-    ) -> ChatCompletionResponse:
-        # make call
-        start = time.time()
-        params = target_template.get_params() \
-            .merge_and_override(self.client_params) \
-            .merge_and_override(completion_parameters)
-        prompt_messages = copy(message_history)
-        if new_messages is not None:
-            prompt_messages.extend(new_messages)
-        completion_response = flavor.continue_chat(messages=prompt_messages,
-                                                   provider_config=provider_config,
-                                                   llm_parameters=params)
-        end = time.time()
-
-        model = flavor.get_model_params(params).get('model')
-        formatted_prompt = json.dumps(prompt_messages)
-        # record data
-        record_call_fields = RecordCallFields(
-            completion_content=completion_response.content,
-            completion_is_complete=completion_response.is_complete,
-            end=end,
-            formatted_prompt=formatted_prompt,
-            session_id=session_id,
-            start=start,
-            target_template=target_template,
-            variables=variables,
-            record_format_type=flavor.record_format_type,
-            tag=tag,
-            test_run_id=test_run_id,
-            test_case_id=None,
-            model=model,
-            provider=flavor.provider,
-            llm_parameters=params,
-            custom_metadata=metadata,
-        )
-        self.record_processor.record_call(record_call_fields)
-
-        return completion_response
-
-    # noinspection PyUnboundLocalVariable
-    def prepare_and_make_chat_call_stream(
-            self,
-            session_id: str,
-            flavor: ChatFlavor,
-            provider_config: ProviderConfig,
-            tag: str,
-            target_template: PromptTemplateWithMetadata,
-            variables: InputVariables,
-            message_history: List[ChatMessage],
-            test_run_id: Optional[str] = None,
-            completion_parameters: Optional[LLMParameters] = None,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = None
-    ) -> Generator[CompletionChunk, None, None]:
-        # make call
-        start = time.time()
-        prompt_messages = copy(message_history)
-        params = target_template.get_params() \
-            .merge_and_override(self.client_params) \
-            .merge_and_override(completion_parameters)
-        completion_response = flavor.continue_chat_stream(prompt_messages, provider_config, llm_parameters=params)
-
-        str_content = ''
-        last_is_complete = False
-        for chunk in completion_response:
-            str_content += chunk.text or ''
-            last_is_complete = chunk.is_complete
-            yield chunk
-        # End time must be logged /after/ streaming the response above, or else OpenAI latency will not be captured.
-        end = time.time()
-
-        model = flavor.get_model_params(params).get('model')
-        formatted_prompt = json.dumps(prompt_messages)
-        record_call_fields = RecordCallFields(
-            completion_content=str_content,
-            completion_is_complete=last_is_complete,
-            end=end,
-            formatted_prompt=formatted_prompt,
-            session_id=session_id,
-            start=start,
-            target_template=target_template,
-            variables=variables,
-            record_format_type=flavor.record_format_type,
-            tag=tag,
-            test_run_id=test_run_id,
-            test_case_id=None,
-            model=model,
-            provider=flavor.provider,
-            llm_parameters=params,
-            custom_metadata=metadata,
-        )
-        self.record_processor.record_call(record_call_fields)
-
-    # noinspection PyUnboundLocalVariable
-    def prepare_and_make_call(
-            self,
-            session_id: str,
-            prompts: PromptTemplates,
-            template_name: str,
-            variables: InputVariables,
-            flavor: Optional[Flavor],
-            provider_config: ProviderConfig,
-            tag: str,
-            test_run_id: Optional[str] = None,
-            completion_parameters: Optional[LLMParameters] = None,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = None
-    ) -> CompletionResponse:
-        target_template = self.find_template_by_name(prompts, template_name)
-        params = target_template.get_params() \
-            .merge_and_override(self.client_params) \
-            .merge_and_override(completion_parameters)
-
-        final_flavor = pick_flavor_from_config(flavor, target_template.flavor_name)
-        formatted_prompt = final_flavor.format(target_template, variables)
-
-        # make call
-        start = time.time()
-        completion_response = final_flavor.call_service(formatted_prompt=formatted_prompt,
-                                                        provider_config=provider_config,
-                                                        llm_parameters=params)
-        end = time.time()
-
-        model = final_flavor.get_model_params(params).get('model')
-
-        # record data
-        record_call_fields = RecordCallFields(
-            completion_content=completion_response.content,
-            completion_is_complete=completion_response.is_complete,
-            end=end,
-            formatted_prompt=formatted_prompt,
-            session_id=session_id,
-            start=start,
-            target_template=target_template,
-            variables=variables,
-            record_format_type=final_flavor.record_format_type,
-            tag=tag,
-            test_run_id=test_run_id,
-            test_case_id=None,
-            model=model,
-            provider=final_flavor.provider,
-            llm_parameters=params,
-            custom_metadata=metadata,
-        )
-        self.record_processor.record_call(record_call_fields)
-
-        return completion_response
-
-    def prepare_and_make_call_stream(
-            self,
-            session_id: str,
-            prompts: PromptTemplates,
-            template_name: str,
-            variables: InputVariables,
-            flavor: Optional[Flavor],
-            provider_config: ProviderConfig,
-            tag: str,
-            test_run_id: Optional[str] = None,
-            completion_parameters: Optional[LLMParameters] = None,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = None
-    ) -> Generator[CompletionChunk, None, None]:
-        target_template = self.find_template_by_name(prompts, template_name)
-        params = target_template.get_params() \
-            .merge_and_override(self.client_params) \
-            .merge_and_override(completion_parameters)
-
-        final_flavor = pick_flavor_from_config(flavor, target_template.flavor_name)
-        formatted_prompt = final_flavor.format(target_template, variables)
-
-        # make call
-        start = int(time.time())
-        completion_response = final_flavor.call_service_stream(
-            formatted_prompt=formatted_prompt, provider_config=provider_config, llm_parameters=params)
-        text_chunks = []
-        last_is_complete = False
-        for chunk in completion_response:
-            text_chunks.append(chunk.text)
-            last_is_complete = chunk.is_complete
-            yield chunk
-        # End time must be logged /after/ streaming the response above, or else OpenAI latency will not be captured.
-        end = int(time.time())
-
-        model = final_flavor.get_model_params(params).get('model')
-
-        record_call_fields = RecordCallFields(
-            completion_content=''.join(text_chunks),
-            completion_is_complete=last_is_complete,
-            end=end,
-            formatted_prompt=formatted_prompt,
-            session_id=session_id,
-            start=start,
-            target_template=target_template,
-            variables=variables,
-            record_format_type=final_flavor.record_format_type,
-            tag=tag,
-            test_run_id=test_run_id,
-            test_case_id=None,
-            model=model,
-            provider=final_flavor.provider,
-            llm_parameters=params,
-            custom_metadata=metadata,
-        )
-        self.record_processor.record_call(record_call_fields)
+        return TestRunResponse(json_dom['test_run_id'], json_dom['test_cases'])