phenoml 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

phenoml/construe/types/extract_request_config.py

@@ -16,7 +16,10 @@ class ExtractRequestConfig(UniversalBaseModel):
 
     max_codes_per_chunk: typing.Optional[int] = pydantic.Field(default=None)
     """
-    Maximum number of codes to extract per chunk
+    Maximum number of codes to extract per chunk. If not specified, uses system-specific defaults:
+    * SNOMED: 10
+    * LOINC, HPO, RXNORM: 20
+    * All other systems: 5
     """
 
     code_similarity_filter: typing.Optional[float] = pydantic.Field(default=None)
@@ -42,6 +45,11 @@ class ExtractRequestConfig(UniversalBaseModel):
     Whether to include ancestor/parent codes in the results
     """
 
+    include_invalid: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Whether to include codes that failed validation in the results
+    """
+
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
     else:

phenoml/construe/types/extracted_code_result.py

@@ -19,6 +19,11 @@ class ExtractedCodeResult(UniversalBaseModel):
     Short description of the code
     """
 
+    valid: bool = pydantic.Field()
+    """
+    Whether the code passed validation. Always true unless include_invalid is set to true, in which case invalid codes will have this set to false.
+    """
+
     long_description: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="longDescription")] = (
         pydantic.Field(default=None)
     )

phenoml/core/client_wrapper.py

@@ -22,10 +22,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "phenoml/v0.0.16",
+            "User-Agent": "phenoml/v0.0.18",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "phenoml",
-            "X-Fern-SDK-Version": "v0.0.16",
+            "X-Fern-SDK-Version": "v0.0.18",
             **(self.get_custom_headers() or {}),
         }
         headers["Authorization"] = f"Bearer {self._get_token()}"

phenoml/lang2fhir/__init__.py

@@ -3,6 +3,11 @@
 # isort: skip_file
 
 from .types import (
+    CreateMultiResponse,
+    CreateMultiResponseBundle,
+    CreateMultiResponseBundleEntryItem,
+    CreateMultiResponseBundleEntryItemRequest,
+    CreateMultiResponseResourcesItem,
     CreateRequestResource,
     DocumentRequestFileType,
     DocumentRequestResource,
@@ -14,6 +19,11 @@ from .errors import BadRequestError, FailedDependencyError, ForbiddenError, Inte
 
 __all__ = [
     "BadRequestError",
+    "CreateMultiResponse",
+    "CreateMultiResponseBundle",
+    "CreateMultiResponseBundleEntryItem",
+    "CreateMultiResponseBundleEntryItemRequest",
+    "CreateMultiResponseResourcesItem",
     "CreateRequestResource",
     "DocumentRequestFileType",
     "DocumentRequestResource",

phenoml/lang2fhir/client.py

@@ -5,6 +5,7 @@ import typing
 from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ..core.request_options import RequestOptions
 from .raw_client import AsyncRawLang2FhirClient, RawLang2FhirClient
+from .types.create_multi_response import CreateMultiResponse
 from .types.create_request_resource import CreateRequestResource
 from .types.document_request_file_type import DocumentRequestFileType
 from .types.document_request_resource import DocumentRequestResource
@@ -79,6 +80,54 @@ class Lang2FhirClient:
         )
         return _response.data
 
+    def create_multi(
+        self,
+        *,
+        text: str,
+        version: typing.Optional[str] = OMIT,
+        provider: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> CreateMultiResponse:
+        """
+        Analyzes natural language text and extracts multiple FHIR resources, returning them as a transaction Bundle.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types from the text.
+        Resources are linked with proper references (e.g., Conditions reference the Patient).
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        provider : typing.Optional[str]
+            Optional FHIR provider name for provider-specific profiles
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        CreateMultiResponse
+            Successfully extracted FHIR resources
+
+        Examples
+        --------
+        from phenoml import phenoml
+
+        client = phenoml(
+            token="YOUR_TOKEN",
+        )
+        client.lang2fhir.create_multi(
+            text="John Smith, 45-year-old male, diagnosed with Type 2 Diabetes. Prescribed Metformin 500mg twice daily.",
+        )
+        """
+        _response = self._raw_client.create_multi(
+            text=text, version=version, provider=provider, request_options=request_options
+        )
+        return _response.data
+
     def search(self, *, text: str, request_options: typing.Optional[RequestOptions] = None) -> SearchResponse:
         """
         Converts natural language text into FHIR search parameters
@@ -278,6 +327,62 @@ class AsyncLang2FhirClient:
         )
         return _response.data
 
+    async def create_multi(
+        self,
+        *,
+        text: str,
+        version: typing.Optional[str] = OMIT,
+        provider: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> CreateMultiResponse:
+        """
+        Analyzes natural language text and extracts multiple FHIR resources, returning them as a transaction Bundle.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types from the text.
+        Resources are linked with proper references (e.g., Conditions reference the Patient).
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        provider : typing.Optional[str]
+            Optional FHIR provider name for provider-specific profiles
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        CreateMultiResponse
+            Successfully extracted FHIR resources
+
+        Examples
+        --------
+        import asyncio
+
+        from phenoml import Asyncphenoml
+
+        client = Asyncphenoml(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.lang2fhir.create_multi(
+                text="John Smith, 45-year-old male, diagnosed with Type 2 Diabetes. Prescribed Metformin 500mg twice daily.",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.create_multi(
+            text=text, version=version, provider=provider, request_options=request_options
+        )
+        return _response.data
+
     async def search(self, *, text: str, request_options: typing.Optional[RequestOptions] = None) -> SearchResponse:
         """
         Converts natural language text into FHIR search parameters

phenoml/lang2fhir/raw_client.py

@@ -13,6 +13,7 @@ from .errors.failed_dependency_error import FailedDependencyError
 from .errors.forbidden_error import ForbiddenError
 from .errors.internal_server_error import InternalServerError
 from .errors.unauthorized_error import UnauthorizedError
+from .types.create_multi_response import CreateMultiResponse
 from .types.create_request_resource import CreateRequestResource
 from .types.document_request_file_type import DocumentRequestFileType
 from .types.document_request_resource import DocumentRequestResource
@@ -120,6 +121,100 @@ class RawLang2FhirClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def create_multi(
+        self,
+        *,
+        text: str,
+        version: typing.Optional[str] = OMIT,
+        provider: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[CreateMultiResponse]:
+        """
+        Analyzes natural language text and extracts multiple FHIR resources, returning them as a transaction Bundle.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types from the text.
+        Resources are linked with proper references (e.g., Conditions reference the Patient).
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        provider : typing.Optional[str]
+            Optional FHIR provider name for provider-specific profiles
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[CreateMultiResponse]
+            Successfully extracted FHIR resources
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "lang2fhir/create/multi",
+            method="POST",
+            json={
+                "text": text,
+                "version": version,
+                "provider": provider,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CreateMultiResponse,
+                    parse_obj_as(
+                        type_=CreateMultiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     def search(
         self, *, text: str, request_options: typing.Optional[RequestOptions] = None
     ) -> HttpResponse[SearchResponse]:
@@ -502,6 +597,100 @@ class AsyncRawLang2FhirClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    async def create_multi(
+        self,
+        *,
+        text: str,
+        version: typing.Optional[str] = OMIT,
+        provider: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[CreateMultiResponse]:
+        """
+        Analyzes natural language text and extracts multiple FHIR resources, returning them as a transaction Bundle.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types from the text.
+        Resources are linked with proper references (e.g., Conditions reference the Patient).
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        provider : typing.Optional[str]
+            Optional FHIR provider name for provider-specific profiles
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[CreateMultiResponse]
+            Successfully extracted FHIR resources
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "lang2fhir/create/multi",
+            method="POST",
+            json={
+                "text": text,
+                "version": version,
+                "provider": provider,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CreateMultiResponse,
+                    parse_obj_as(
+                        type_=CreateMultiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     async def search(
         self, *, text: str, request_options: typing.Optional[RequestOptions] = None
     ) -> AsyncHttpResponse[SearchResponse]:

phenoml/lang2fhir/types/__init__.py

@@ -2,6 +2,11 @@
 
 # isort: skip_file
 
+from .create_multi_response import CreateMultiResponse
+from .create_multi_response_bundle import CreateMultiResponseBundle
+from .create_multi_response_bundle_entry_item import CreateMultiResponseBundleEntryItem
+from .create_multi_response_bundle_entry_item_request import CreateMultiResponseBundleEntryItemRequest
+from .create_multi_response_resources_item import CreateMultiResponseResourcesItem
 from .create_request_resource import CreateRequestResource
 from .document_request_file_type import DocumentRequestFileType
 from .document_request_resource import DocumentRequestResource
@@ -10,6 +15,11 @@ from .lang2fhir_upload_profile_response import Lang2FhirUploadProfileResponse
 from .search_response import SearchResponse
 
 __all__ = [
+    "CreateMultiResponse",
+    "CreateMultiResponseBundle",
+    "CreateMultiResponseBundleEntryItem",
+    "CreateMultiResponseBundleEntryItemRequest",
+    "CreateMultiResponseResourcesItem",
     "CreateRequestResource",
     "DocumentRequestFileType",
     "DocumentRequestResource",

phenoml/lang2fhir/types/create_multi_response.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .create_multi_response_bundle import CreateMultiResponseBundle
+from .create_multi_response_resources_item import CreateMultiResponseResourcesItem
+
+
+class CreateMultiResponse(UniversalBaseModel):
+    success: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Whether extraction was successful
+    """
+
+    message: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    Status message
+    """
+
+    bundle: typing.Optional[CreateMultiResponseBundle] = pydantic.Field(default=None)
+    """
+    FHIR transaction Bundle containing all extracted resources
+    """
+
+    resources: typing.Optional[typing.List[CreateMultiResponseResourcesItem]] = pydantic.Field(default=None)
+    """
+    Summary of extracted resources
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/lang2fhir/types/create_multi_response_bundle.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+import typing_extensions
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ...core.serialization import FieldMetadata
+from .create_multi_response_bundle_entry_item import CreateMultiResponseBundleEntryItem
+
+
+class CreateMultiResponseBundle(UniversalBaseModel):
+    """
+    FHIR transaction Bundle containing all extracted resources
+    """
+
+    resource_type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="resourceType")] = None
+    type: typing.Optional[str] = None
+    entry: typing.Optional[typing.List[CreateMultiResponseBundleEntryItem]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/lang2fhir/types/create_multi_response_bundle_entry_item.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+import typing_extensions
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ...core.serialization import FieldMetadata
+from .create_multi_response_bundle_entry_item_request import CreateMultiResponseBundleEntryItemRequest
+
+
+class CreateMultiResponseBundleEntryItem(UniversalBaseModel):
+    full_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="fullUrl")] = None
+    resource: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
+    request: typing.Optional[CreateMultiResponseBundleEntryItemRequest] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/lang2fhir/types/create_multi_response_bundle_entry_item_request.py

@@ -0,0 +1,20 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class CreateMultiResponseBundleEntryItemRequest(UniversalBaseModel):
+    method: typing.Optional[str] = None
+    url: typing.Optional[str] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/lang2fhir/types/create_multi_response_resources_item.py

@@ -0,0 +1,38 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+import typing_extensions
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ...core.serialization import FieldMetadata
+
+
+class CreateMultiResponseResourcesItem(UniversalBaseModel):
+    temp_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="tempId")] = pydantic.Field(
+        default=None
+    )
+    """
+    Temporary UUID for the resource
+    """
+
+    resource_type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="resourceType")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    FHIR resource type
+    """
+
+    description: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    Text excerpt this resource was extracted from
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/tools/__init__.py

@@ -4,6 +4,9 @@
 
 from .types import (
     CohortResponse,
+    Lang2FhirAndCreateMultiResponse,
+    Lang2FhirAndCreateMultiResponseResourceInfoItem,
+    Lang2FhirAndCreateMultiResponseResponseBundle,
     Lang2FhirAndCreateRequestResource,
     Lang2FhirAndCreateResponse,
     Lang2FhirAndSearchResponse,
@@ -23,6 +26,9 @@ __all__ = [
     "FailedDependencyError",
     "ForbiddenError",
     "InternalServerError",
+    "Lang2FhirAndCreateMultiResponse",
+    "Lang2FhirAndCreateMultiResponseResourceInfoItem",
+    "Lang2FhirAndCreateMultiResponseResponseBundle",
     "Lang2FhirAndCreateRequestResource",
     "Lang2FhirAndCreateResponse",
     "Lang2FhirAndSearchResponse",

phenoml/tools/client.py

@@ -7,6 +7,7 @@ from ..core.request_options import RequestOptions
 from .mcp_server.client import AsyncMcpServerClient, McpServerClient
 from .raw_client import AsyncRawToolsClient, RawToolsClient
 from .types.cohort_response import CohortResponse
+from .types.lang2fhir_and_create_multi_response import Lang2FhirAndCreateMultiResponse
 from .types.lang2fhir_and_create_request_resource import Lang2FhirAndCreateRequestResource
 from .types.lang2fhir_and_create_response import Lang2FhirAndCreateResponse
 from .types.lang2fhir_and_search_response import Lang2FhirAndSearchResponse
@@ -95,6 +96,74 @@ class ToolsClient:
         )
         return _response.data
 
+    def create_fhir_resources_multi(
+        self,
+        *,
+        text: str,
+        provider: str,
+        phenoml_on_behalf_of: typing.Optional[str] = None,
+        phenoml_fhir_provider: typing.Optional[str] = None,
+        version: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Lang2FhirAndCreateMultiResponse:
+        """
+        Extracts multiple FHIR resources from natural language text and stores them in a FHIR server.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types.
+        Resources are linked with proper references and submitted as a transaction bundle.
+        For FHIR servers that don't auto-resolve urn:uuid references, this endpoint will automatically
+        resolve them via PUT requests after the initial bundle creation.
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        provider : str
+            FHIR provider ID or name
+
+        phenoml_on_behalf_of : typing.Optional[str]
+            Optional header for on-behalf-of authentication. Used when making requests on behalf of another user or entity.
+            Must be in the format: Patient/{uuid} or Practitioner/{uuid}
+
+        phenoml_fhir_provider : typing.Optional[str]
+            Optional header for FHIR provider authentication. Contains credentials in the format {fhir_provider_id}:{oauth2_token}.
+            Multiple FHIR provider integrations can be provided as comma-separated values.
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Lang2FhirAndCreateMultiResponse
+            Successfully created FHIR resources
+
+        Examples
+        --------
+        from phenoml import phenoml
+
+        client = phenoml(
+            token="YOUR_TOKEN",
+        )
+        client.tools.create_fhir_resources_multi(
+            phenoml_on_behalf_of="Patient/550e8400-e29b-41d4-a716-446655440000",
+            phenoml_fhir_provider="550e8400-e29b-41d4-a716-446655440000:eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c...",
+            text="John Smith, 45-year-old male, diagnosed with Type 2 Diabetes. Prescribed Metformin 500mg twice daily.",
+            provider="medplum",
+        )
+        """
+        _response = self._raw_client.create_fhir_resources_multi(
+            text=text,
+            provider=provider,
+            phenoml_on_behalf_of=phenoml_on_behalf_of,
+            phenoml_fhir_provider=phenoml_fhir_provider,
+            version=version,
+            request_options=request_options,
+        )
+        return _response.data
+
     def search_fhir_resources(
         self,
         *,
@@ -316,6 +385,82 @@ class AsyncToolsClient:
         )
         return _response.data
 
+    async def create_fhir_resources_multi(
+        self,
+        *,
+        text: str,
+        provider: str,
+        phenoml_on_behalf_of: typing.Optional[str] = None,
+        phenoml_fhir_provider: typing.Optional[str] = None,
+        version: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> Lang2FhirAndCreateMultiResponse:
+        """
+        Extracts multiple FHIR resources from natural language text and stores them in a FHIR server.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types.
+        Resources are linked with proper references and submitted as a transaction bundle.
+        For FHIR servers that don't auto-resolve urn:uuid references, this endpoint will automatically
+        resolve them via PUT requests after the initial bundle creation.
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        provider : str
+            FHIR provider ID or name
+
+        phenoml_on_behalf_of : typing.Optional[str]
+            Optional header for on-behalf-of authentication. Used when making requests on behalf of another user or entity.
+            Must be in the format: Patient/{uuid} or Practitioner/{uuid}
+
+        phenoml_fhir_provider : typing.Optional[str]
+            Optional header for FHIR provider authentication. Contains credentials in the format {fhir_provider_id}:{oauth2_token}.
+            Multiple FHIR provider integrations can be provided as comma-separated values.
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        Lang2FhirAndCreateMultiResponse
+            Successfully created FHIR resources
+
+        Examples
+        --------
+        import asyncio
+
+        from phenoml import Asyncphenoml
+
+        client = Asyncphenoml(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.tools.create_fhir_resources_multi(
+                phenoml_on_behalf_of="Patient/550e8400-e29b-41d4-a716-446655440000",
+                phenoml_fhir_provider="550e8400-e29b-41d4-a716-446655440000:eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c...",
+                text="John Smith, 45-year-old male, diagnosed with Type 2 Diabetes. Prescribed Metformin 500mg twice daily.",
+                provider="medplum",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.create_fhir_resources_multi(
+            text=text,
+            provider=provider,
+            phenoml_on_behalf_of=phenoml_on_behalf_of,
+            phenoml_fhir_provider=phenoml_fhir_provider,
+            version=version,
+            request_options=request_options,
+        )
+        return _response.data
+
     async def search_fhir_resources(
         self,
         *,

phenoml/tools/raw_client.py

@@ -14,6 +14,7 @@ from .errors.forbidden_error import ForbiddenError
 from .errors.internal_server_error import InternalServerError
 from .errors.unauthorized_error import UnauthorizedError
 from .types.cohort_response import CohortResponse
+from .types.lang2fhir_and_create_multi_response import Lang2FhirAndCreateMultiResponse
 from .types.lang2fhir_and_create_request_resource import Lang2FhirAndCreateRequestResource
 from .types.lang2fhir_and_create_response import Lang2FhirAndCreateResponse
 from .types.lang2fhir_and_search_response import Lang2FhirAndSearchResponse
@@ -152,6 +153,136 @@ class RawToolsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def create_fhir_resources_multi(
+        self,
+        *,
+        text: str,
+        provider: str,
+        phenoml_on_behalf_of: typing.Optional[str] = None,
+        phenoml_fhir_provider: typing.Optional[str] = None,
+        version: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[Lang2FhirAndCreateMultiResponse]:
+        """
+        Extracts multiple FHIR resources from natural language text and stores them in a FHIR server.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types.
+        Resources are linked with proper references and submitted as a transaction bundle.
+        For FHIR servers that don't auto-resolve urn:uuid references, this endpoint will automatically
+        resolve them via PUT requests after the initial bundle creation.
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        provider : str
+            FHIR provider ID or name
+
+        phenoml_on_behalf_of : typing.Optional[str]
+            Optional header for on-behalf-of authentication. Used when making requests on behalf of another user or entity.
+            Must be in the format: Patient/{uuid} or Practitioner/{uuid}
+
+        phenoml_fhir_provider : typing.Optional[str]
+            Optional header for FHIR provider authentication. Contains credentials in the format {fhir_provider_id}:{oauth2_token}.
+            Multiple FHIR provider integrations can be provided as comma-separated values.
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[Lang2FhirAndCreateMultiResponse]
+            Successfully created FHIR resources
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "tools/lang2fhir-and-create-multi",
+            method="POST",
+            json={
+                "text": text,
+                "version": version,
+                "provider": provider,
+            },
+            headers={
+                "content-type": "application/json",
+                "X-Phenoml-On-Behalf-Of": str(phenoml_on_behalf_of) if phenoml_on_behalf_of is not None else None,
+                "X-Phenoml-Fhir-Provider": str(phenoml_fhir_provider) if phenoml_fhir_provider is not None else None,
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    Lang2FhirAndCreateMultiResponse,
+                    parse_obj_as(
+                        type_=Lang2FhirAndCreateMultiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 424:
+                raise FailedDependencyError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     def search_fhir_resources(
         self,
         *,
@@ -529,6 +660,136 @@ class AsyncRawToolsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    async def create_fhir_resources_multi(
+        self,
+        *,
+        text: str,
+        provider: str,
+        phenoml_on_behalf_of: typing.Optional[str] = None,
+        phenoml_fhir_provider: typing.Optional[str] = None,
+        version: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[Lang2FhirAndCreateMultiResponse]:
+        """
+        Extracts multiple FHIR resources from natural language text and stores them in a FHIR server.
+        Automatically detects Patient, Condition, MedicationRequest, Observation, and other resource types.
+        Resources are linked with proper references and submitted as a transaction bundle.
+        For FHIR servers that don't auto-resolve urn:uuid references, this endpoint will automatically
+        resolve them via PUT requests after the initial bundle creation.
+
+        Parameters
+        ----------
+        text : str
+            Natural language text containing multiple clinical concepts to extract
+
+        provider : str
+            FHIR provider ID or name
+
+        phenoml_on_behalf_of : typing.Optional[str]
+            Optional header for on-behalf-of authentication. Used when making requests on behalf of another user or entity.
+            Must be in the format: Patient/{uuid} or Practitioner/{uuid}
+
+        phenoml_fhir_provider : typing.Optional[str]
+            Optional header for FHIR provider authentication. Contains credentials in the format {fhir_provider_id}:{oauth2_token}.
+            Multiple FHIR provider integrations can be provided as comma-separated values.
+
+        version : typing.Optional[str]
+            FHIR version to use
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[Lang2FhirAndCreateMultiResponse]
+            Successfully created FHIR resources
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "tools/lang2fhir-and-create-multi",
+            method="POST",
+            json={
+                "text": text,
+                "version": version,
+                "provider": provider,
+            },
+            headers={
+                "content-type": "application/json",
+                "X-Phenoml-On-Behalf-Of": str(phenoml_on_behalf_of) if phenoml_on_behalf_of is not None else None,
+                "X-Phenoml-Fhir-Provider": str(phenoml_fhir_provider) if phenoml_fhir_provider is not None else None,
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    Lang2FhirAndCreateMultiResponse,
+                    parse_obj_as(
+                        type_=Lang2FhirAndCreateMultiResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 424:
+                raise FailedDependencyError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     async def search_fhir_resources(
         self,
         *,

phenoml/tools/types/__init__.py

@@ -3,6 +3,9 @@
 # isort: skip_file
 
 from .cohort_response import CohortResponse
+from .lang2fhir_and_create_multi_response import Lang2FhirAndCreateMultiResponse
+from .lang2fhir_and_create_multi_response_resource_info_item import Lang2FhirAndCreateMultiResponseResourceInfoItem
+from .lang2fhir_and_create_multi_response_response_bundle import Lang2FhirAndCreateMultiResponseResponseBundle
 from .lang2fhir_and_create_request_resource import Lang2FhirAndCreateRequestResource
 from .lang2fhir_and_create_response import Lang2FhirAndCreateResponse
 from .lang2fhir_and_search_response import Lang2FhirAndSearchResponse
@@ -15,6 +18,9 @@ from .search_concept import SearchConcept
 
 __all__ = [
     "CohortResponse",
+    "Lang2FhirAndCreateMultiResponse",
+    "Lang2FhirAndCreateMultiResponseResourceInfoItem",
+    "Lang2FhirAndCreateMultiResponseResponseBundle",
     "Lang2FhirAndCreateRequestResource",
     "Lang2FhirAndCreateResponse",
     "Lang2FhirAndSearchResponse",

phenoml/tools/types/lang2fhir_and_create_multi_response.py

@@ -0,0 +1,41 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .lang2fhir_and_create_multi_response_resource_info_item import Lang2FhirAndCreateMultiResponseResourceInfoItem
+from .lang2fhir_and_create_multi_response_response_bundle import Lang2FhirAndCreateMultiResponseResponseBundle
+
+
+class Lang2FhirAndCreateMultiResponse(UniversalBaseModel):
+    success: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Whether the resources were created successfully
+    """
+
+    message: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    Status message
+    """
+
+    response_bundle: typing.Optional[Lang2FhirAndCreateMultiResponseResponseBundle] = pydantic.Field(default=None)
+    """
+    FHIR transaction-response Bundle from the server with resolved resource IDs
+    """
+
+    resource_info: typing.Optional[typing.List[Lang2FhirAndCreateMultiResponseResourceInfoItem]] = pydantic.Field(
+        default=None
+    )
+    """
+    Metadata about created resources (temp IDs, types, descriptions)
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/tools/types/lang2fhir_and_create_multi_response_resource_info_item.py

@@ -0,0 +1,38 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+import typing_extensions
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ...core.serialization import FieldMetadata
+
+
+class Lang2FhirAndCreateMultiResponseResourceInfoItem(UniversalBaseModel):
+    temp_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="tempId")] = pydantic.Field(
+        default=None
+    )
+    """
+    Original temporary UUID
+    """
+
+    resource_type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="resourceType")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    FHIR resource type
+    """
+
+    description: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    Text excerpt this resource was extracted from
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/tools/types/lang2fhir_and_create_multi_response_response_bundle.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+import typing_extensions
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from ...core.serialization import FieldMetadata
+
+
+class Lang2FhirAndCreateMultiResponseResponseBundle(UniversalBaseModel):
+    """
+    FHIR transaction-response Bundle from the server with resolved resource IDs
+    """
+
+    resource_type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="resourceType")] = None
+    type: typing.Optional[str] = None
+    entry: typing.Optional[typing.List[typing.Dict[str, typing.Optional[typing.Any]]]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

{phenoml-0.0.16.dist-info → phenoml-0.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phenoml
-Version: 0.0.16
+Version: 0.0.18
 Summary: 
 Requires-Python: >=3.8,<4.0
 Classifier: Intended Audience :: Developers

{phenoml-0.0.16.dist-info → phenoml-0.0.18.dist-info}/RECORD

@@ -70,15 +70,15 @@ phenoml/construe/raw_client.py,sha256=xXhtTmLzDELw9TEXWSKk9ZK2UXYNKMfp3IAk2EKxzl
 phenoml/construe/types/__init__.py,sha256=Id0OJ58ZEQX9Ut-7iMwWEv49MTJLTTmNPH9es1ya8Cw,900
 phenoml/construe/types/construe_upload_code_system_response.py,sha256=s0m5EHpkhkp7hYiC5zLZeIeqQ4mrwXlPI1Msihb-ZGo,566
 phenoml/construe/types/extract_codes_result.py,sha256=DbVDLWqtmt9TyD5MC0q8grgnNXPnXq4eJnLDinTe0uc,701
-phenoml/construe/types/extract_request_config.py,sha256=-N_yPxXcWeuFx2JNOJIGHjtyJNSFMOGslmLbjYxMh18,1831
+phenoml/construe/types/extract_request_config.py,sha256=2A22PNA1Hxq9qz1x89LvbySF-Hw8iB6oA2QqoSIrvg8,2112
 phenoml/construe/types/extract_request_config_chunking_method.py,sha256=AmVPPj0oT5r0pwWUoFxG_K8s5g8xaGYIRsPt3VvqSXQ,209
 phenoml/construe/types/extract_request_config_validation_method.py,sha256=6uUqKn8DXF34EDtNKPa6KLW07DsxgQF2aR5BGdG5Fd4,199
 phenoml/construe/types/extract_request_system.py,sha256=50qkxvinJKS5y1_glr-OFe5tQRyMWLYpeny1NZ9gFzw,1191
-phenoml/construe/types/extracted_code_result.py,sha256=LmhaQYFeLXBWR_NWcF1c-qt3OqwWQduefvInJRHcvio,1121
+phenoml/construe/types/extracted_code_result.py,sha256=3mIHO952KjbMRBY_YvwBt75XOjqdflg9Odc-xBbURac,1321
 phenoml/construe/types/upload_request_format.py,sha256=5mJhMM7R7hn6gGQNDJT9lxPDsRpUkRzqNxtRU0Nnlls,158
 phenoml/core/__init__.py,sha256=lTcqUPXcx4112yLDd70RAPeqq6tu3eFMe1pKOqkW9JQ,1562
 phenoml/core/api_error.py,sha256=44vPoTyWN59gonCIZMdzw7M1uspygiLnr3GNFOoVL2Q,614
-phenoml/core/client_wrapper.py,sha256=jUWGtvhTYtnP_U6RqZrJmxAQWdCH8x-eMwO-XW6PzrI,2645
+phenoml/core/client_wrapper.py,sha256=z1oi8fHFvxZesnHRdmy1-aaGsidR3l0xTrlWWgY_50o,2645
 phenoml/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 phenoml/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 phenoml/core/force_multipart.py,sha256=awxh5MtcRYe74ehY8U76jzv6fYM_w_D3Rur7KQQzSDk,429
@@ -136,16 +136,21 @@ phenoml/fhir_provider/types/provider.py,sha256=AmGOmoy5Cv9W0km4rAf3mxqH3g3UUnj_x
 phenoml/fhir_provider/types/role.py,sha256=Igag80s-KaGOc4nWfrGWyT81HU__c6_WJ-1oV7DOVdE,638
 phenoml/fhir_provider/types/service_account_key.py,sha256=uup1Xl0HSc_B3278i0CS-ygCroShLS5_q0KtqXI96HY,1085
 phenoml/fhir_provider/types/smart_configuration.py,sha256=bG_J1yNFEWWo9kjxF0s2Ik9rXehB1JHcQ2fTn6dht6k,1174
-phenoml/lang2fhir/__init__.py,sha256=R8VOE03BLTk90GJVBfpiUXHeODUNX3rZLkRIC21s1ow,694
-phenoml/lang2fhir/client.py,sha256=HxOpDPSihtgHJq3ayaKsGPUl48wA-FG89-268MYb_sU,12810
+phenoml/lang2fhir/__init__.py,sha256=zgnos0Sw2t255KUygG-lhZGl9yQCLPTJM7uMssWm1pc,1066
+phenoml/lang2fhir/client.py,sha256=o86CP8qO_K6BFBv3sj1KY8lBr37ccH2pGWXyB7APUuA,16289
 phenoml/lang2fhir/errors/__init__.py,sha256=nIzg981R3USgSar0WuuVrpDVg-H5vIp2AceEzbhphGw,458
 phenoml/lang2fhir/errors/bad_request_error.py,sha256=nv0bK4gtOnTon6a2NdVxJxHBje_O_7wIoRtXLZHovUQ,339
 phenoml/lang2fhir/errors/failed_dependency_error.py,sha256=eXiqG062inkUF7fs2Newhx9uAKReK6fosz29PMD4gVw,345
 phenoml/lang2fhir/errors/forbidden_error.py,sha256=ek8-sffTy9gY3F0zyaSkcskDVvq9puXP_YvvB2BJYbA,338
 phenoml/lang2fhir/errors/internal_server_error.py,sha256=biBHJfSP1_zWF5CJgxY4B8wrL1uC18RSccQ-BCKmYNs,343
 phenoml/lang2fhir/errors/unauthorized_error.py,sha256=h8T6QhXuTo0GLL9MKfIM5p--wDqlB1-ZkMp3lY-aM3E,341
-phenoml/lang2fhir/raw_client.py,sha256=aJfhWF7OIYjGU-lq7eKfR-a5LNiX6ANI3jVOe1HAD2c,30786
-phenoml/lang2fhir/types/__init__.py,sha256=QIcpkgfIOpA_5Nwwymnk-WtyozrBJ-D4d4GwLKLCUpA,619
+phenoml/lang2fhir/raw_client.py,sha256=uQN6oXZ7OD21Vvf_YOvOBrG56Eqbn79KMsPmq7RvIl4,38328
+phenoml/lang2fhir/types/__init__.py,sha256=IDh7nk6AXkWbzy2gbjQ11I0YLr8J6XzD2gCcBbRIPWI,1207
+phenoml/lang2fhir/types/create_multi_response.py,sha256=GrOBnwDp7pSmCRqaaG_4jL0P1lqXYMk5ioTabVaP2zg,1212
+phenoml/lang2fhir/types/create_multi_response_bundle.py,sha256=os13oK7NULRoN647NBfE3QuKe2Gvi2qSa6KJpkWIHsA,994
+phenoml/lang2fhir/types/create_multi_response_bundle_entry_item.py,sha256=1qvcTZuE_WzOzwGs6CrQOaU9cCFdtH2A7EGhMR8aqL4,970
+phenoml/lang2fhir/types/create_multi_response_bundle_entry_item_request.py,sha256=R-qHcnHjFz8rSYYDlo2Yqi7_Ul4jZtleE0BYhFA0jnE,612
+phenoml/lang2fhir/types/create_multi_response_resources_item.py,sha256=VFggDG3w6KpskIVeSKInNrcgCFmlYmz1IFNGvMJq7hk,1119
 phenoml/lang2fhir/types/create_request_resource.py,sha256=JyfWUXGae-BMEvjtbDqQVNyIL4Qoh7nJwJyHOwP070Q,596
 phenoml/lang2fhir/types/document_request_file_type.py,sha256=VgPYn7FB-5hgvNsyvQEGIsEQ6F4ruM4VN9TWxr_Tfv4,212
 phenoml/lang2fhir/types/document_request_resource.py,sha256=keHsMn9UxgHd9VUNT54Atcj4Z4YI9uU0Fj9g1RwGUrg,189
@@ -176,8 +181,8 @@ phenoml/summary/types/summary_get_template_response.py,sha256=u71jGARazI2XECeqmR
 phenoml/summary/types/summary_list_templates_response.py,sha256=go45lFGp3KktaZq4lCGN5KV6SYbaik5bNvn5NkTV6xI,678
 phenoml/summary/types/summary_template.py,sha256=eCM6BVMZC4jxp7d2PoIfcluflAMXa07oZcXf0nzytXM,1269
 phenoml/summary/types/summary_update_template_response.py,sha256=1i_2LELTdulyXLNaEaN10Phy9KZfmGUBQCcj_9eZZy4,706
-phenoml/tools/__init__.py,sha256=tWbUCa1RVpte1Ov53WgLExOXvGT72Mol2JM1Ul3nj3M,989
-phenoml/tools/client.py,sha256=JRLj2mUGWuJ_ClRiSRimSKxx55hWQOLtPACpvFFVqxw,18261
+phenoml/tools/__init__.py,sha256=pbSU1CU2J38xaBZbvsMw3tNvbmmgCw8b1lKERCeIxY4,1277
+phenoml/tools/client.py,sha256=jChK5oGyxOaIrk4Me9cL8ZZlnA1ZsDWP3oLlkuABMBM,24324
 phenoml/tools/errors/__init__.py,sha256=nIzg981R3USgSar0WuuVrpDVg-H5vIp2AceEzbhphGw,458
 phenoml/tools/errors/bad_request_error.py,sha256=nv0bK4gtOnTon6a2NdVxJxHBje_O_7wIoRtXLZHovUQ,339
 phenoml/tools/errors/failed_dependency_error.py,sha256=eXiqG062inkUF7fs2Newhx9uAKReK6fosz29PMD4gVw,345
@@ -190,9 +195,12 @@ phenoml/tools/mcp_server/raw_client.py,sha256=AVnepraHeEuI4zl1eBeHC3_-mkc7zfEIeY
 phenoml/tools/mcp_server/tools/__init__.py,sha256=_VhToAyIt_5axN6CLJwtxg3-CO7THa_23pbUzqhXJa4,85
 phenoml/tools/mcp_server/tools/client.py,sha256=iu-AclviqNB9NWfkS_h7LY9exfzPGmAjOG3MIbQgtuk,9807
 phenoml/tools/mcp_server/tools/raw_client.py,sha256=FC_OQZ526AGrN1lAnYLvtr-s8NrHfcKUpxM_YLKZgos,26380
-phenoml/tools/raw_client.py,sha256=AdHQW0jlx-QtysAT2lo8DuxFZE1rsU_ji8EbPfLrVPc,33432
-phenoml/tools/types/__init__.py,sha256=Q9a9RbiUDz9jFLZi_43I40t8ZZuolzaDtluYJWV8yN8,1021
+phenoml/tools/raw_client.py,sha256=kBKvgWNOcLqvmSDfzdmKfaXTiLGnAMfW52bjOssEKDc,44916
+phenoml/tools/types/__init__.py,sha256=6mlBraLARj7_4mVEaAktqY-T8PYZO_dkyMSkzPDjLo0,1476
 phenoml/tools/types/cohort_response.py,sha256=Nft1eLyFhNrKDNYOhQxzSH1o35JS7UdZlTgI9ndjdVM,1503
+phenoml/tools/types/lang2fhir_and_create_multi_response.py,sha256=vFgylAXNd_hwclVpvDbFXdEcGRjFWNHL34XHNz_LhEg,1427
+phenoml/tools/types/lang2fhir_and_create_multi_response_resource_info_item.py,sha256=TJEcnb2IPs_OJnOicLDZF9hOwPJEBWHmN-28tZ3yZas,1126
+phenoml/tools/types/lang2fhir_and_create_multi_response_response_bundle.py,sha256=cUXGEUJuqEINdtqPyMW_zEOnHeto96scQnM6FL04zOU,954
 phenoml/tools/types/lang2fhir_and_create_request_resource.py,sha256=mIBUXOfKrweiYsCu-vxboK_uDu43GQUEdKWlVLHMOyU,608
 phenoml/tools/types/lang2fhir_and_create_response.py,sha256=jyEYZ_A3JSgVz0dwmlvbzKVMhj4C4SbmeOWbtVDV9uo,971
 phenoml/tools/types/lang2fhir_and_search_response.py,sha256=RaJ5zd-D1yFxRyINjksvcefGc81RfIFw_5WmhE4T7HQ,1146
@@ -237,7 +245,7 @@ phenoml/workflows/types/workflows_delete_response.py,sha256=izcubUOnSNOgThD9Ozo6
 phenoml/workflows/types/workflows_get_response.py,sha256=gfNyUs14JSynprRwT-fuq4IDsGrPZmUSsK3WmgqIEi8,891
 phenoml/workflows/types/workflows_update_response.py,sha256=FEvQpC9ZRk8dV1oaIAwV5bSDD2tkXZ5fG4mozRjibuQ,1046
 phenoml/wrapper_client.py,sha256=JYTdhXgju4tOsata06wQY_ZbMsuMj3qaxkgvDzpY068,5022
-phenoml-0.0.16.dist-info/LICENSE,sha256=Am1fNNveR2gcmOloSWQTsnUw2SQEF8HtowFqIvlagfk,1064
-phenoml-0.0.16.dist-info/METADATA,sha256=OThqy03xut7-0sX_5DNEriUHduGA1vfP4LixDBtIH0w,5331
-phenoml-0.0.16.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-phenoml-0.0.16.dist-info/RECORD,,
+phenoml-0.0.18.dist-info/LICENSE,sha256=Am1fNNveR2gcmOloSWQTsnUw2SQEF8HtowFqIvlagfk,1064
+phenoml-0.0.18.dist-info/METADATA,sha256=Z1ieeoLMuZTCh90F_ExzmBFAU_0f9EJ74r7UOmrvfEE,5331
+phenoml-0.0.18.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+phenoml-0.0.18.dist-info/RECORD,,