orca-sdk 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

orca_sdk/client.py

@@ -6,15 +6,31 @@ import json
 import logging
 import os
 import uuid
+from contextlib import contextmanager
+from contextvars import ContextVar
 from string import Formatter
-from typing import Any, Literal, Mapping, NotRequired, TypedDict, cast, overload
+from typing import (
+    Any,
+    Callable,
+    Generator,
+    Literal,
+    Mapping,
+    NotRequired,
+    Self,
+    TypedDict,
+    cast,
+    overload,
+)
 
 from httpx import (
     URL,
     USE_CLIENT_DEFAULT,
+    BaseTransport,
     Client,
     Headers,
     HTTPTransport,
+    Limits,
+    Proxy,
     Request,
     Response,
     Timeout,
@@ -243,6 +259,11 @@ class LabelClassMetrics(TypedDict):
     memory_count: int
 
 
+class LabelPercentage(TypedDict):
+    label: int | None
+    percentage: float
+
+
 class LabeledExample(TypedDict):
     text: str
     label_name: str
@@ -335,16 +356,31 @@ class MemorysetClusterMetrics(TypedDict):
 class MemorysetConceptAnalysisConfig(TypedDict):
     high_level_description: NotRequired[str | None]
     max_sample_rows: NotRequired[int]
+    min_lookup_count: NotRequired[int]
+    max_lookup_count: NotRequired[int]
+    overlap_decay_tau: NotRequired[float]
+    target_lcc_fraction: NotRequired[float]
+    min_cluster_count: NotRequired[int]
+    max_cluster_count: NotRequired[int]
     max_trial_count: NotRequired[int]
-    min_desired_clusters_per_label: NotRequired[int]
-    max_desired_clusters_per_label: NotRequired[int]
-    accuracy_importance: NotRequired[float]
-    noise_penalty: NotRequired[float]
+    resolution: NotRequired[float]
+    iterations: NotRequired[int]
+    use_generative_naming: NotRequired[bool]
     naming_examples_count: NotRequired[int]
     naming_counterexample_count: NotRequired[int]
     seed: NotRequired[int]
 
 
+class MemorysetDistributionAnalysisConfig(TypedDict):
+    neighbor_counts: NotRequired[list[int]]
+    quantiles: NotRequired[list[float]]
+
+
+class MemorysetDistributionMetrics(TypedDict):
+    lookup_score_metrics: dict[str, LookupScoreMetrics]
+    updated_at: str
+
+
 class MemorysetDuplicateAnalysisConfig(TypedDict):
     potential_duplicate_threshold: NotRequired[float]
 
@@ -370,16 +406,6 @@ class MemorysetLabelMetrics(TypedDict):
     updated_at: str
 
 
-class MemorysetNeighborAnalysisConfig(TypedDict):
-    neighbor_counts: NotRequired[list[int]]
-    quantiles: NotRequired[list[float]]
-
-
-class MemorysetNeighborMetrics(TypedDict):
-    lookup_score_metrics: dict[str, LookupScoreMetrics]
-    updated_at: str
-
-
 class MemorysetProjectionAnalysisConfig(TypedDict):
     min_dist: NotRequired[float]
     spread: NotRequired[float]
@@ -415,8 +441,8 @@ class NotFoundErrorResponse(TypedDict):
             "pretrained_embedding_model",
             "finetuned_embedding_model",
             "feedback_category",
-            "embedding_evaluation",
             "org_plan",
+            "worker",
         ]
         | None
     )
@@ -733,6 +759,13 @@ class ValidationError(TypedDict):
     type: str
 
 
+WorkerStatus = Literal["IDLE", "BUSY", "DRAINING", "SHUTDOWN", "CRASHED"]
+
+
+class GetTestErrorByStatusCodeParams(TypedDict):
+    status_code: int | Literal["error", "warning"]
+
+
 class DeleteAuthApiKeyByNameOrIdParams(TypedDict):
     name_or_id: str
 
@@ -830,6 +863,10 @@ class GetFinetunedEmbeddingModelByNameOrIdEvaluationByTaskIdParams(TypedDict):
 
 class GetFinetunedEmbeddingModelByNameOrIdEvaluationsParams(TypedDict):
     name_or_id: str
+    datasource: NotRequired[str | None]
+    value_column: NotRequired[str | None]
+    label_column: NotRequired[str | None]
+    score_column: NotRequired[str | None]
 
 
 class GetPretrainedEmbeddingModelByModelNameParams(TypedDict):
@@ -847,6 +884,10 @@ class GetPretrainedEmbeddingModelByModelNameEvaluationByTaskIdParams(TypedDict):
 
 class GetPretrainedEmbeddingModelByModelNameEvaluationsParams(TypedDict):
     model_name: PretrainedEmbeddingModelName
+    datasource: NotRequired[str | None]
+    value_column: NotRequired[str | None]
+    label_column: NotRequired[str | None]
+    score_column: NotRequired[str | None]
 
 
 class PostDatasourceUploadRequest(TypedDict):
@@ -868,20 +909,11 @@ class DeleteDatasourceByNameOrIdParams(TypedDict):
     name_or_id: str
 
 
-class PostDatasourceByNameOrIdEmbeddingEvaluationParams(TypedDict):
-    name_or_id: str
-
-
-class GetDatasourceByNameOrIdEmbeddingEvaluationParams(TypedDict):
-    name_or_id: str
-    status: NotRequired[TaskStatus | None]
-    limit: NotRequired[int | None]
-    offset: NotRequired[int | None]
-
-
-class GetDatasourceByNameOrIdEmbeddingEvaluationByTaskIdParams(TypedDict):
+class GetDatasourceByNameOrIdEmbeddingModelEvaluationsParams(TypedDict):
     name_or_id: str
-    task_id: str
+    value_column: NotRequired[str | None]
+    label_column: NotRequired[str | None]
+    score_column: NotRequired[str | None]
 
 
 class GetDatasourceByNameOrIdDownloadParams(TypedDict):
@@ -976,6 +1008,16 @@ class DeleteTaskByTaskIdAbortParams(TypedDict):
     task_id: str
 
 
+class GetWorkerParams(TypedDict):
+    status: NotRequired[WorkerStatus | list[WorkerStatus] | None]
+    limit: NotRequired[int | None]
+    offset: NotRequired[int]
+
+
+class GetWorkerByWorkerIdParams(TypedDict):
+    worker_id: str
+
+
 class GetTelemetryPredictionByPredictionIdParams(TypedDict):
     prediction_id: str
 
@@ -1154,6 +1196,7 @@ class ConceptMetrics(TypedDict):
     primary_label: int | None
     memory_count: int
     subconcepts: list[SubConceptMetrics]
+    label_percentages: list[LabelPercentage]
 
 
 class CreateClassificationModelRequest(TypedDict):
@@ -1187,6 +1230,7 @@ class CreateMemorysetRequest(TypedDict):
     index_params: NotRequired[dict[str, int | float | str]]
     prompt: NotRequired[str]
     hidden: NotRequired[bool]
+    batch_size: NotRequired[int]
 
 
 class CreateRegressionModelRequest(TypedDict):
@@ -1198,25 +1242,6 @@ class CreateRegressionModelRequest(TypedDict):
     head_type: NotRequired[RARHeadType]
 
 
-class DatasourceEmbeddingEvaluationsRequest(TypedDict):
-    value_column: str
-    label_column: str
-    source_id_column: str | None
-    neighbor_count: NotRequired[int]
-    label_names: NotRequired[list[str] | None]
-    embedding_models: NotRequired[list[PretrainedEmbeddingModelName | str] | None]
-
-
-class DatasourceEmbeddingEvaluationsTaskPayload(TypedDict):
-    value_column: str
-    label_column: str
-    source_id_column: str | None
-    neighbor_count: NotRequired[int]
-    label_names: NotRequired[list[str] | None]
-    embedding_models: NotRequired[list[PretrainedEmbeddingModelName | str] | None]
-    datasource_id: str
-
-
 class DatasourceMetadata(TypedDict):
     id: str
     org_id: str
@@ -1232,29 +1257,21 @@ class DatasourceMetadata(TypedDict):
 class EmbeddingEvaluationResponse(TypedDict):
     task_id: str
     org_id: str
+    finetuned_embedding_model_id: str | None
+    pretrained_embedding_model_name: PretrainedEmbeddingModelName | None
+    datasource_id: str
+    subsample: int | None
+    datasource_value_column: str
+    datasource_label_column: NotRequired[str | None]
+    datasource_score_column: NotRequired[str | None]
+    neighbor_count: int
+    weigh_memories: bool
     status: TaskStatus
     result: ClassificationMetrics | RegressionMetrics | None
     created_at: str
     updated_at: str
 
 
-class EmbeddingEvaluationResponseUnionClassificationMetricsRegressionMetrics(TypedDict):
-    task_id: str
-    org_id: str
-    status: TaskStatus
-    result: ClassificationMetrics | RegressionMetrics | None
-    created_at: str
-    updated_at: str
-
-
-class EmbeddingModelResult(TypedDict):
-    embedding_model_name: str
-    embedding_model_path: str
-    analysis_result: MemorysetLabelMetrics
-    memoryset_name: NotRequired[str | None]
-    is_finetuned: NotRequired[bool]
-
-
 class EvaluationResponse(TypedDict):
     task_id: str
     org_id: str
@@ -1429,7 +1446,7 @@ class ListPredictionsRequest(TypedDict):
 
 
 class MemorysetAnalysisConfigs(TypedDict):
-    neighbor: NotRequired[MemorysetNeighborAnalysisConfig | None]
+    distribution: NotRequired[MemorysetDistributionAnalysisConfig | None]
     label: NotRequired[MemorysetLabelAnalysisConfig | None]
     duplicate: NotRequired[MemorysetDuplicateAnalysisConfig | None]
     projection: NotRequired[MemorysetProjectionAnalysisConfig | None]
@@ -1452,7 +1469,7 @@ class MemorysetConceptMetrics(TypedDict):
 
 
 class MemorysetMetrics(TypedDict):
-    neighbor: NotRequired[MemorysetNeighborMetrics | None]
+    distribution: NotRequired[MemorysetDistributionMetrics | None]
     label: NotRequired[MemorysetLabelMetrics | None]
     duplicate: NotRequired[MemorysetDuplicateMetrics | None]
     projection: NotRequired[MemorysetProjectionMetrics | None]
@@ -1487,10 +1504,12 @@ class Task(TypedDict):
     created_at: str
     id: str
     org_id: str
+    worker_id: str | None
     type: str
     payload: BaseModel
     result: BaseModel | None
-    depends_on: NotRequired[list[str]]
+    depends_on: list[str]
+    lease_token: str | None
 
 
 class TelemetryMemoriesRequest(TypedDict):
@@ -1501,6 +1520,16 @@ class TelemetryMemoriesRequest(TypedDict):
     sort: NotRequired[list[TelemetrySortOptions] | None]
 
 
+class WorkerInfo(TypedDict):
+    id: str
+    status: WorkerStatus
+    started_at: str
+    updated_at: str
+    version: str | None
+    git_sha: str
+    config: dict[str, str | float | int | bool | dict[str, str] | None]
+
+
 PatchGpuMemorysetByNameOrIdMemoryRequest = LabeledMemoryUpdate | ScoredMemoryUpdate
 
 
@@ -1513,10 +1542,6 @@ class CascadingEditSuggestion(TypedDict):
     lookup_score: float
 
 
-class EmbeddingEvaluationResult(TypedDict):
-    evaluation_results: list[EmbeddingModelResult]
-
-
 class MemorysetAnalysisResponse(TypedDict):
     task_id: str
     org_id: str
@@ -1564,6 +1589,13 @@ class PaginatedTask(TypedDict):
     limit: int
 
 
+class PaginatedWorkerInfo(TypedDict):
+    items: list[WorkerInfo]
+    total: int
+    offset: int
+    limit: int
+
+
 class BootstrapClassificationModelMeta(TypedDict):
     datasource_meta: DatasourceMetadata
     memoryset_meta: MemorysetMetadata
@@ -1579,17 +1611,6 @@ class BootstrapClassificationModelResponse(TypedDict):
     input: BootstrapClassificationModelRequest | None
 
 
-class DatasourceEmbeddingEvaluationsResponse(TypedDict):
-    task_id: str
-    org_id: str
-    datasource_id: str
-    status: TaskStatus
-    result: EmbeddingEvaluationResult | None
-    payload: DatasourceEmbeddingEvaluationsTaskPayload
-    created_at: str
-    updated_at: str
-
-
 class OrcaClient(Client):
     @staticmethod
     def _parse_params(
@@ -1604,11 +1625,11 @@ class OrcaClient(Client):
         return path_params, query_params
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/cleanup"],
+        path: Literal["/test_error/{status_code}"],
         *,
-        params: None = None,
+        params: GetTestErrorByStatusCodeParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1616,16 +1637,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> CleanupResponse:
-        """Cleanup orphaned milvus collections and blobs"""
+    ) -> Any:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/auth/api_key/{name_or_id}"],
+        path: Literal["/check/alive"],
         *,
-        params: DeleteAuthApiKeyByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1633,14 +1653,13 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
-        """Delete an API key by name or ID."""
+    ) -> AliveResponse:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/auth/org"],
+        path: Literal["/check/ready"],
         *,
         params: None = None,
         parse_as: Literal["json"] = "json",
@@ -1650,16 +1669,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
-        """Deletes the org and all associated resources"""
+    ) -> ReadyResponse:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/memoryset/{name_or_id}"],
+        path: Literal["/gpu/check/healthy"],
         *,
-        params: DeleteMemorysetByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1667,15 +1685,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
+    ) -> HealthyResponse:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/memoryset/{name_or_id}/memory/{memory_id}"],
+        path: Literal["/check/healthy"],
         *,
-        params: DeleteMemorysetByNameOrIdMemoryByMemoryIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1683,15 +1701,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
+    ) -> HealthyResponse:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/finetuned_embedding_model/{name_or_id}"],
+        path: Literal["/gpu/config"],
         *,
-        params: DeleteFinetunedEmbeddingModelByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1699,16 +1717,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
-        """Delete a finetuned embedding model by name or ID."""
+    ) -> dict[str, str | float | int | bool | None]:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/datasource/{name_or_id}"],
+        path: Literal["/config"],
         *,
-        params: DeleteDatasourceByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1716,16 +1733,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
-        """Delete a datasource by name or ID."""
+    ) -> dict[str, str | float | int | bool | None]:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/classification_model/{name_or_id}"],
+        path: Literal["/auth/root"],
         *,
-        params: DeleteClassificationModelByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1733,15 +1749,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
+    ) -> bool:
+        """Return true only when called with a valid root API key; otherwise 401 Unauthenticated."""
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/classification_model/{model_name_or_id}/evaluation/{task_id}"],
+        path: Literal["/auth/api_key"],
         *,
-        params: DeleteClassificationModelByModelNameOrIdEvaluationByTaskIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1749,15 +1766,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
+    ) -> list[ApiKeyMetadata]:
+        """List all API keys for the organization."""
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/regression_model/{name_or_id}"],
+        path: Literal["/auth"],
         *,
-        params: DeleteRegressionModelByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1765,15 +1783,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
+    ) -> bool:
+        """Returns true if the api key header is valid for the org (will be false for admin api key)"""
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/regression_model/{model_name_or_id}/evaluation/{task_id}"],
+        path: Literal["/auth/org/plan"],
         *,
-        params: DeleteRegressionModelByModelNameOrIdEvaluationByTaskIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1781,15 +1800,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
+    ) -> OrgPlan:
+        """Get the organization plan."""
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/task/{task_id}/abort"],
+        path: Literal["/memoryset"],
         *,
-        params: DeleteTaskByTaskIdAbortParams,
+        params: GetMemorysetParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1797,15 +1817,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
+    ) -> list[MemorysetMetadata]:
         pass
 
     @overload
-    def DELETE(
+    def GET(
         self,
-        path: Literal["/telemetry/feedback_category/{name_or_id}"],
+        path: Literal["/memoryset/{name_or_id}"],
         *,
-        params: DeleteTelemetryFeedbackCategoryByNameOrIdParams,
+        params: GetMemorysetByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1813,46 +1833,31 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> None:
-        """Delete a feedback category and all associated feedback records."""
+    ) -> MemorysetMetadata:
         pass
 
-    def DELETE(
+    @overload
+    def GET(
         self,
-        path: str,
+        path: Literal["/memoryset/{name_or_id}/memory/{memory_id}"],
         *,
-        params: Mapping[str, Any] | None = None,
-        parse_as: Literal["json", "text"] | None = "json",
+        params: GetMemorysetByNameOrIdMemoryByMemoryIdParams,
+        parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> Any:
-        path_params, query_params = self._parse_params(params or {}, path)
-        res = self.delete(
-            path.format(**path_params),
-            params=query_params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        ).raise_for_status()
-        return (
-            None
-            if res.status_code == 204
-            else res.json() if parse_as == "json" else res.text if parse_as == "text" else res.content
-        )
+    ) -> LabeledMemory | ScoredMemory:
+        pass
 
     @overload
     def GET(
         self,
-        path: Literal["/check/alive"],
+        path: Literal["/memoryset/{name_or_id}/potential_duplicate_groups"],
         *,
-        params: None = None,
+        params: GetMemorysetByNameOrIdPotentialDuplicateGroupsParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1860,15 +1865,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> AliveResponse:
+    ) -> list[list[LabeledMemory]] | list[list[ScoredMemory]]:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/check/ready"],
+        path: Literal["/memoryset/{name_or_id}/analysis"],
         *,
-        params: None = None,
+        params: GetMemorysetByNameOrIdAnalysisParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1876,15 +1881,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> ReadyResponse:
+    ) -> list[MemorysetAnalysisResponse]:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/gpu/check/healthy"],
+        path: Literal["/memoryset/{name_or_id}/analysis/{analysis_task_id}"],
         *,
-        params: None = None,
+        params: GetMemorysetByNameOrIdAnalysisByAnalysisTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1892,13 +1897,13 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> HealthyResponse:
+    ) -> MemorysetAnalysisResponse:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/check/healthy"],
+        path: Literal["/finetuned_embedding_model"],
         *,
         params: None = None,
         parse_as: Literal["json"] = "json",
@@ -1908,15 +1913,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> HealthyResponse:
+    ) -> list[FinetunedEmbeddingModelMetadata]:
+        """List all finetuned embedding models for the organization."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/gpu/config"],
+        path: Literal["/finetuned_embedding_model/{name_or_id}"],
         *,
-        params: None = None,
+        params: GetFinetunedEmbeddingModelByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1924,15 +1930,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> dict[str, str | float | int | bool | None]:
+    ) -> FinetunedEmbeddingModelMetadata:
+        """Get a finetuned embedding model by name or ID."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/config"],
+        path: Literal["/finetuned_embedding_model/{name_or_id}/evaluation/{task_id}"],
         *,
-        params: None = None,
+        params: GetFinetunedEmbeddingModelByNameOrIdEvaluationByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1940,47 +1947,50 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> dict[str, str | float | int | bool | None]:
+    ) -> EmbeddingEvaluationResponse:
+        """Get evaluation results for a finetuned embedding model by task ID."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/gpu/"],
+        path: Literal["/finetuned_embedding_model/{name_or_id}/evaluations"],
         *,
-        params: None = None,
-        parse_as: Literal["text"],
+        params: GetFinetunedEmbeddingModelByNameOrIdEvaluationsParams,
+        parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> str:
+    ) -> list[EmbeddingEvaluationResponse]:
+        """List all evaluation results for a finetuned embedding model."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/"],
+        path: Literal["/pretrained_embedding_model"],
         *,
         params: None = None,
-        parse_as: Literal["text"],
+        parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> str:
+    ) -> list[PretrainedEmbeddingModelMetadata]:
+        """List all available pretrained embedding models."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/auth/root"],
+        path: Literal["/pretrained_embedding_model/{model_name}"],
         *,
-        params: None = None,
+        params: GetPretrainedEmbeddingModelByModelNameParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -1988,16 +1998,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> bool:
-        """Return true only when called with a valid root API key; otherwise 401 Unauthenticated."""
+    ) -> PretrainedEmbeddingModelMetadata:
+        """Get metadata for a specific pretrained embedding model."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/auth/api_key"],
+        path: Literal["/pretrained_embedding_model/{model_name}/evaluation/{task_id}"],
         *,
-        params: None = None,
+        params: GetPretrainedEmbeddingModelByModelNameEvaluationByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2005,16 +2015,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[ApiKeyMetadata]:
-        """List all API keys for the organization."""
+    ) -> EmbeddingEvaluationResponse:
+        """Get evaluation results for a pretrained embedding model by task ID."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/auth"],
+        path: Literal["/pretrained_embedding_model/{model_name}/evaluations"],
         *,
-        params: None = None,
+        params: GetPretrainedEmbeddingModelByModelNameEvaluationsParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2022,14 +2032,14 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> bool:
-        """Returns true if the api key header is valid for the org (will be false for admin api key)"""
+    ) -> list[EmbeddingEvaluationResponse]:
+        """List all evaluation results for a pretrained embedding model."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/auth/org/plan"],
+        path: Literal["/datasource"],
         *,
         params: None = None,
         parse_as: Literal["json"] = "json",
@@ -2039,16 +2049,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> OrgPlan:
-        """Get the organization plan."""
+    ) -> list[DatasourceMetadata]:
+        """List all datasources for the organization."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/memoryset"],
+        path: Literal["/datasource/{name_or_id}"],
         *,
-        params: GetMemorysetParams,
+        params: GetDatasourceByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2056,15 +2066,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[MemorysetMetadata]:
+    ) -> DatasourceMetadata:
+        """Get a datasource by name or ID."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/memoryset/{name_or_id}"],
+        path: Literal["/datasource/{name_or_id}/embedding_model_evaluations"],
         *,
-        params: GetMemorysetByNameOrIdParams,
+        params: GetDatasourceByNameOrIdEmbeddingModelEvaluationsParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2072,15 +2083,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> MemorysetMetadata:
+    ) -> list[EmbeddingEvaluationResponse]:
+        """List all evaluation results for a datasource."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/memoryset/{name_or_id}/memory/{memory_id}"],
+        path: Literal["/datasource/{name_or_id}/download"],
         *,
-        params: GetMemorysetByNameOrIdMemoryByMemoryIdParams,
+        params: GetDatasourceByNameOrIdDownloadParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2088,47 +2100,50 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> LabeledMemory | ScoredMemory:
+    ) -> list[dict[str, Any]]:
+        """Download datasource in the specified format."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/memoryset/{name_or_id}/potential_duplicate_groups"],
+        path: Literal["/datasource/{name_or_id}/download"],
         *,
-        params: GetMemorysetByNameOrIdPotentialDuplicateGroupsParams,
-        parse_as: Literal["json"] = "json",
+        params: GetDatasourceByNameOrIdDownloadParams,
+        parse_as: Literal["text"],
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[list[LabeledMemory]] | list[list[ScoredMemory]]:
+    ) -> str:
+        """Download datasource in the specified format."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/memoryset/{name_or_id}/analysis"],
+        path: Literal["/datasource/{name_or_id}/download"],
         *,
-        params: GetMemorysetByNameOrIdAnalysisParams,
-        parse_as: Literal["json"] = "json",
+        params: GetDatasourceByNameOrIdDownloadParams,
+        parse_as: None,
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[MemorysetAnalysisResponse]:
+    ) -> bytes:
+        """Download datasource in the specified format."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/memoryset/{name_or_id}/analysis/{analysis_task_id}"],
+        path: Literal["/predictive_model"],
         *,
-        params: GetMemorysetByNameOrIdAnalysisByAnalysisTaskIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2136,13 +2151,13 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> MemorysetAnalysisResponse:
+    ) -> list[ClassificationModelMetadata | RegressionModelMetadata]:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/finetuned_embedding_model"],
+        path: Literal["/classification_model"],
         *,
         params: None = None,
         parse_as: Literal["json"] = "json",
@@ -2152,16 +2167,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[FinetunedEmbeddingModelMetadata]:
-        """List all finetuned embedding models for the organization."""
+    ) -> list[ClassificationModelMetadata]:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/finetuned_embedding_model/{name_or_id}"],
+        path: Literal["/classification_model/{name_or_id}"],
         *,
-        params: GetFinetunedEmbeddingModelByNameOrIdParams,
+        params: GetClassificationModelByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2169,16 +2183,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> FinetunedEmbeddingModelMetadata:
-        """Get a finetuned embedding model by name or ID."""
+    ) -> ClassificationModelMetadata:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/finetuned_embedding_model/{name_or_id}/evaluation/{task_id}"],
+        path: Literal["/classification_model/{model_name_or_id}/evaluation"],
         *,
-        params: GetFinetunedEmbeddingModelByNameOrIdEvaluationByTaskIdParams,
+        params: GetClassificationModelByModelNameOrIdEvaluationParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2186,16 +2199,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> EmbeddingEvaluationResponseUnionClassificationMetricsRegressionMetrics:
-        """Get evaluation results for a finetuned embedding model by task ID."""
+    ) -> list[EvaluationResponseClassificationMetrics]:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/finetuned_embedding_model/{name_or_id}/evaluations"],
+        path: Literal["/classification_model/{model_name_or_id}/evaluation/{task_id}"],
         *,
-        params: GetFinetunedEmbeddingModelByNameOrIdEvaluationsParams,
+        params: GetClassificationModelByModelNameOrIdEvaluationByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2203,14 +2215,13 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[EmbeddingEvaluationResponseUnionClassificationMetricsRegressionMetrics]:
-        """List all evaluation results for a finetuned embedding model."""
+    ) -> EvaluationResponseClassificationMetrics:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/pretrained_embedding_model"],
+        path: Literal["/regression_model"],
         *,
         params: None = None,
         parse_as: Literal["json"] = "json",
@@ -2220,16 +2231,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[PretrainedEmbeddingModelMetadata]:
-        """List all available pretrained embedding models."""
+    ) -> list[RegressionModelMetadata]:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/pretrained_embedding_model/{model_name}"],
+        path: Literal["/regression_model/{name_or_id}"],
         *,
-        params: GetPretrainedEmbeddingModelByModelNameParams,
+        params: GetRegressionModelByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2237,16 +2247,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> PretrainedEmbeddingModelMetadata:
-        """Get metadata for a specific pretrained embedding model."""
+    ) -> RegressionModelMetadata:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/pretrained_embedding_model/{model_name}/evaluation/{task_id}"],
+        path: Literal["/regression_model/{model_name_or_id}/evaluation"],
         *,
-        params: GetPretrainedEmbeddingModelByModelNameEvaluationByTaskIdParams,
+        params: GetRegressionModelByModelNameOrIdEvaluationParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2254,16 +2263,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> EmbeddingEvaluationResponseUnionClassificationMetricsRegressionMetrics:
-        """Get evaluation results for a pretrained embedding model by task ID."""
+    ) -> list[EvaluationResponseRegressionMetrics]:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/pretrained_embedding_model/{model_name}/evaluations"],
+        path: Literal["/regression_model/{model_name_or_id}/evaluation/{task_id}"],
         *,
-        params: GetPretrainedEmbeddingModelByModelNameEvaluationsParams,
+        params: GetRegressionModelByModelNameOrIdEvaluationByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2271,16 +2279,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[EmbeddingEvaluationResponseUnionClassificationMetricsRegressionMetrics]:
-        """List all evaluation results for a pretrained embedding model."""
+    ) -> EvaluationResponseRegressionMetrics:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/datasource"],
+        path: Literal["/task/{task_id}"],
         *,
-        params: None = None,
+        params: GetTaskByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2288,16 +2295,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[DatasourceMetadata]:
-        """List all datasources for the organization."""
+    ) -> Task:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/datasource/{name_or_id}"],
+        path: Literal["/task/{task_id}/status"],
         *,
-        params: GetDatasourceByNameOrIdParams,
+        params: GetTaskByTaskIdStatusParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2305,16 +2311,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> DatasourceMetadata:
-        """Get a datasource by name or ID."""
+    ) -> TaskStatusInfo:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/datasource/{name_or_id}/embedding_evaluation"],
+        path: Literal["/task"],
         *,
-        params: GetDatasourceByNameOrIdEmbeddingEvaluationParams,
+        params: GetTaskParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2322,16 +2327,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[DatasourceEmbeddingEvaluationsResponse]:
-        """List embedding evaluation tasks for a datasource."""
+    ) -> PaginatedTask:
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/datasource/{name_or_id}/embedding_evaluation/{task_id}"],
+        path: Literal["/worker"],
         *,
-        params: GetDatasourceByNameOrIdEmbeddingEvaluationByTaskIdParams,
+        params: GetWorkerParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2339,16 +2343,20 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> DatasourceEmbeddingEvaluationsResponse:
-        """Get an embedding evaluation task by ID."""
+    ) -> PaginatedWorkerInfo:
+        """
+        List all workers in the system. Requires root access.
+
+        This endpoint automatically cleans up orphaned workers before returning results.
+        """
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/datasource/{name_or_id}/download"],
+        path: Literal["/worker/{worker_id}"],
         *,
-        params: GetDatasourceByNameOrIdDownloadParams,
+        params: GetWorkerByWorkerIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2356,50 +2364,50 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[dict[str, Any]]:
-        """Download datasource in the specified format."""
+    ) -> WorkerInfo:
+        """Get information about a specific worker. Requires root access."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/datasource/{name_or_id}/download"],
+        path: Literal["/telemetry/prediction/{prediction_id}"],
         *,
-        params: GetDatasourceByNameOrIdDownloadParams,
-        parse_as: Literal["text"],
+        params: GetTelemetryPredictionByPredictionIdParams,
+        parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> str:
-        """Download datasource in the specified format."""
+    ) -> LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback:
+        """Get a specific prediction by ID."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/datasource/{name_or_id}/download"],
+        path: Literal["/telemetry/prediction/{prediction_id}/explanation"],
         *,
-        params: GetDatasourceByNameOrIdDownloadParams,
-        parse_as: None,
+        params: GetTelemetryPredictionByPredictionIdExplanationParams,
+        parse_as: Literal["text"],
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> bytes:
-        """Download datasource in the specified format."""
+    ) -> str:
+        """Get explanation for a prediction, optionally streaming the response."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/predictive_model"],
+        path: Literal["/telemetry/prediction/{prediction_id}/action"],
         *,
-        params: None = None,
+        params: GetTelemetryPredictionByPredictionIdActionParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2407,15 +2415,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[ClassificationModelMetadata | RegressionModelMetadata]:
+    ) -> ActionRecommendation:
+        """Get action recommendation for improving a specific prediction."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/classification_model"],
+        path: Literal["/telemetry/prediction/{prediction_id}/memory_suggestions"],
         *,
-        params: None = None,
+        params: GetTelemetryPredictionByPredictionIdMemorySuggestionsParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2423,15 +2432,21 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[ClassificationModelMetadata]:
+    ) -> AddMemoryRecommendations:
+        """
+        Generate synthetic memory suggestions to improve a specific prediction.
+
+        The returned suggestions have labels as string representations of integer indices
+        corresponding to the memoryset's label_names.
+        """
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/classification_model/{name_or_id}"],
+        path: Literal["/telemetry/feedback_category"],
         *,
-        params: GetClassificationModelByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2439,15 +2454,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> ClassificationModelMetadata:
+    ) -> list[PredictionFeedbackCategory]:
+        """List all feedback categories for the organization."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/classification_model/{model_name_or_id}/evaluation"],
+        path: Literal["/telemetry/feedback_category/{name_or_id}"],
         *,
-        params: GetClassificationModelByModelNameOrIdEvaluationParams,
+        params: GetTelemetryFeedbackCategoryByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2455,15 +2471,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[EvaluationResponseClassificationMetrics]:
+    ) -> PredictionFeedbackCategory:
+        """Get a feedback category by name or ID."""
         pass
 
     @overload
     def GET(
         self,
-        path: Literal["/classification_model/{model_name_or_id}/evaluation/{task_id}"],
+        path: Literal["/agents/bootstrap_classification_model/{task_id}"],
         *,
-        params: GetClassificationModelByModelNameOrIdEvaluationByTaskIdParams,
+        params: GetAgentsBootstrapClassificationModelByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2471,31 +2488,47 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> EvaluationResponseClassificationMetrics:
+    ) -> BootstrapClassificationModelResponse:
+        """Get the status of a bootstrap classification model task"""
         pass
 
-    @overload
     def GET(
         self,
-        path: Literal["/regression_model"],
+        path: str,
         *,
-        params: None = None,
-        parse_as: Literal["json"] = "json",
+        params: Mapping[str, Any] | None = None,
+        parse_as: Literal["json", "text"] | None = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[RegressionModelMetadata]:
-        pass
+    ) -> Any:
+        path_params, query_params = self._parse_params(params or {}, path)
+        res = self.get(
+            path.format(**path_params),
+            params=query_params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        res.raise_for_status()
+        return (
+            None
+            if res.status_code == 204
+            else res.json() if parse_as == "json" else res.text if parse_as == "text" else res.content
+        )
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/regression_model/{name_or_id}"],
+        path: Literal["/cleanup"],
         *,
-        params: GetRegressionModelByNameOrIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2503,15 +2536,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> RegressionModelMetadata:
+    ) -> CleanupResponse:
+        """Cleanup orphaned milvus collections and blobs"""
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/regression_model/{model_name_or_id}/evaluation"],
+        path: Literal["/auth/api_key/{name_or_id}"],
         *,
-        params: GetRegressionModelByModelNameOrIdEvaluationParams,
+        params: DeleteAuthApiKeyByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2519,15 +2553,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[EvaluationResponseRegressionMetrics]:
+    ) -> None:
+        """Delete an API key by name or ID."""
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/regression_model/{model_name_or_id}/evaluation/{task_id}"],
+        path: Literal["/auth/org"],
         *,
-        params: GetRegressionModelByModelNameOrIdEvaluationByTaskIdParams,
+        params: None = None,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2535,15 +2570,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> EvaluationResponseRegressionMetrics:
+    ) -> None:
+        """Deletes the org and all associated resources"""
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/task/{task_id}"],
+        path: Literal["/memoryset/{name_or_id}"],
         *,
-        params: GetTaskByTaskIdParams,
+        params: DeleteMemorysetByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2551,15 +2587,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> Task:
+    ) -> None:
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/task/{task_id}/status"],
+        path: Literal["/memoryset/{name_or_id}/memory/{memory_id}"],
         *,
-        params: GetTaskByTaskIdStatusParams,
+        params: DeleteMemorysetByNameOrIdMemoryByMemoryIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2567,15 +2603,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> TaskStatusInfo:
+    ) -> None:
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/task"],
+        path: Literal["/finetuned_embedding_model/{name_or_id}"],
         *,
-        params: GetTaskParams,
+        params: DeleteFinetunedEmbeddingModelByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2583,15 +2619,16 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> PaginatedTask:
+    ) -> None:
+        """Delete a finetuned embedding model by name or ID."""
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/telemetry/prediction/{prediction_id}"],
+        path: Literal["/datasource/{name_or_id}"],
         *,
-        params: GetTelemetryPredictionByPredictionIdParams,
+        params: DeleteDatasourceByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2599,33 +2636,32 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback:
-        """Get a specific prediction by ID."""
+    ) -> None:
+        """Delete a datasource by name or ID."""
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/telemetry/prediction/{prediction_id}/explanation"],
+        path: Literal["/classification_model/{name_or_id}"],
         *,
-        params: GetTelemetryPredictionByPredictionIdExplanationParams,
-        parse_as: Literal["text"],
+        params: DeleteClassificationModelByNameOrIdParams,
+        parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
         auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> str:
-        """Get explanation for a prediction, optionally streaming the response."""
+    ) -> None:
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/telemetry/prediction/{prediction_id}/action"],
+        path: Literal["/classification_model/{model_name_or_id}/evaluation/{task_id}"],
         *,
-        params: GetTelemetryPredictionByPredictionIdActionParams,
+        params: DeleteClassificationModelByModelNameOrIdEvaluationByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2633,16 +2669,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> ActionRecommendation:
-        """Get action recommendation for improving a specific prediction."""
+    ) -> None:
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/telemetry/prediction/{prediction_id}/memory_suggestions"],
+        path: Literal["/regression_model/{name_or_id}"],
         *,
-        params: GetTelemetryPredictionByPredictionIdMemorySuggestionsParams,
+        params: DeleteRegressionModelByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2650,21 +2685,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> AddMemoryRecommendations:
-        """
-        Generate synthetic memory suggestions to improve a specific prediction.
-
-        The returned suggestions have labels as string representations of integer indices
-        corresponding to the memoryset's label_names.
-        """
+    ) -> None:
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/telemetry/feedback_category"],
+        path: Literal["/regression_model/{model_name_or_id}/evaluation/{task_id}"],
         *,
-        params: None = None,
+        params: DeleteRegressionModelByModelNameOrIdEvaluationByTaskIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2672,16 +2701,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> list[PredictionFeedbackCategory]:
-        """List all feedback categories for the organization."""
+    ) -> None:
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/telemetry/feedback_category/{name_or_id}"],
+        path: Literal["/task/{task_id}/abort"],
         *,
-        params: GetTelemetryFeedbackCategoryByNameOrIdParams,
+        params: DeleteTaskByTaskIdAbortParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2689,16 +2717,15 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> PredictionFeedbackCategory:
-        """Get a feedback category by name or ID."""
+    ) -> None:
         pass
 
     @overload
-    def GET(
+    def DELETE(
         self,
-        path: Literal["/agents/bootstrap_classification_model/{task_id}"],
+        path: Literal["/telemetry/feedback_category/{name_or_id}"],
         *,
-        params: GetAgentsBootstrapClassificationModelByTaskIdParams,
+        params: DeleteTelemetryFeedbackCategoryByNameOrIdParams,
         parse_as: Literal["json"] = "json",
         headers: HeaderTypes | None = None,
         cookies: CookieTypes | None = None,
@@ -2706,11 +2733,11 @@ class OrcaClient(Client):
         follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
         timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
         extensions: RequestExtensions | None = None,
-    ) -> BootstrapClassificationModelResponse:
-        """Get the status of a bootstrap classification model task"""
+    ) -> None:
+        """Delete a feedback category and all associated feedback records."""
         pass
 
-    def GET(
+    def DELETE(
         self,
         path: str,
         *,
@@ -2724,7 +2751,7 @@ class OrcaClient(Client):
         extensions: RequestExtensions | None = None,
     ) -> Any:
         path_params, query_params = self._parse_params(params or {}, path)
-        res = self.get(
+        res = self.delete(
             path.format(**path_params),
             params=query_params,
             headers=headers,
@@ -2733,7 +2760,8 @@ class OrcaClient(Client):
             follow_redirects=follow_redirects,
             timeout=timeout,
             extensions=extensions,
-        ).raise_for_status()
+        )
+        res.raise_for_status()
         return (
             None
             if res.status_code == 204
@@ -3059,27 +3087,6 @@ class OrcaClient(Client):
         """
         pass
 
-    @overload
-    def POST(
-        self,
-        path: Literal["/datasource/{name_or_id}/embedding_evaluation"],
-        *,
-        params: PostDatasourceByNameOrIdEmbeddingEvaluationParams,
-        json: DatasourceEmbeddingEvaluationsRequest,
-        data: None = None,
-        files: None = None,
-        content: None = None,
-        parse_as: Literal["json"] = "json",
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> DatasourceEmbeddingEvaluationsResponse:
-        """Create an embedding evaluation task for a datasource."""
-        pass
-
     @overload
     def POST(
         self,
@@ -3414,7 +3421,8 @@ class OrcaClient(Client):
             follow_redirects=follow_redirects,
             timeout=timeout,
             extensions=extensions,
-        ).raise_for_status()
+        )
+        res.raise_for_status()
         return (
             None
             if res.status_code == 204
@@ -3494,7 +3502,8 @@ class OrcaClient(Client):
             follow_redirects=follow_redirects,
             timeout=timeout,
             extensions=extensions,
-        ).raise_for_status()
+        )
+        res.raise_for_status()
         return (
             None
             if res.status_code == 204
@@ -3653,95 +3662,126 @@ class OrcaClient(Client):
             follow_redirects=follow_redirects,
             timeout=timeout,
             extensions=extensions,
-        ).raise_for_status()
+        )
+        res.raise_for_status()
         return (
             None
             if res.status_code == 204
             else res.json() if parse_as == "json" else res.text if parse_as == "text" else res.content
         )
 
-    @property
-    def base_url(self) -> URL:
-        # lazy init base_url from environment variable
-        if str(self._base_url) == "":
-            self.base_url = os.environ.get("ORCA_API_URL", "https://api.orcadb.ai/")
-        return self._base_url
+    @staticmethod
+    def _raise_error_for_response(response: Response) -> None:
+        if response.status_code == 401:
+            raise ValueError("Invalid API key")
+        # elif response.status_code == 402:
+        #     res = cast(QuotaExceededErrorResponse, json.loads(response.read().decode(response.encoding or "utf-8")))
+        #     raise RuntimeError(
+        #         f"{res['quota_type'].replace('_', ' ').title()} limit reached ({res['current']}/{res['quota_limit']})"
+        #     )
+        elif response.status_code == 403:
+            raise PermissionError(json.loads(response.read().decode(response.encoding or "utf-8"))["reason"])
+        elif response.status_code == 404:
+            res = cast(NotFoundErrorResponse, json.loads(response.read().decode(response.encoding or "utf-8")))
+            if res["resource"] is not None:
+                raise LookupError(f"The {res['resource']} you are looking for does not exist")
+            else:
+                raise RuntimeError(f"Unknown API route: {response.url}")
+        elif response.status_code == 405:
+            raise RuntimeError(f"Unknown method {response.request.method} for API route: {response.url}")
+        elif response.status_code == 409:
+            res = cast(
+                ConstraintViolationErrorResponse, json.loads(response.read().decode(response.encoding or "utf-8"))
+            )
+            raise RuntimeError(res["constraint"])
+        elif response.status_code == 422:
+            res = cast(InvalidInputErrorResponse, json.loads(response.read().decode(response.encoding or "utf-8")))
+            issues = [f"{issue['loc'][-1]}: {issue['msg']}" for issue in res["validation_issues"]]
+            raise ValueError("Invalid input:\n\t" + "\n\t".join(issues))
+        elif response.status_code == 500:
+            res = cast(InternalServerErrorResponse, json.loads(response.read().decode(response.encoding or "utf-8")))
+            raise RuntimeError(f"Unexpected server error: {res['message']}")
+        elif response.status_code == 503:
+            raise RuntimeError("Orca API is currently unavailable, please try again later")
+        elif response.status_code >= 400:
+            raise RuntimeError(f"Unexpected status code: {response.status_code}")
+
+    @staticmethod
+    def _instrument_request(request: Request) -> None:
+        request.headers["X-Request-ID"] = str(uuid.uuid4())
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        base_url: URL | str = "",
+        headers: HeaderTypes | None = None,
+        transport: BaseTransport | None = None,
+        timeout: TimeoutTypes | None = None,
+        limits: Limits | None = None,
+        max_redirects: int = 20,
+        event_hooks: None | (Mapping[str, list[Callable[..., Any]]]) = None,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: str | URL | Proxy | None = None,
+        log_level: int = logging.WARNING,
+    ) -> None:
+        """
+        Initialize an OrcaAPI httpx client
 
-    @base_url.setter
-    def base_url(self, url: URL | str) -> None:
-        Client.base_url.__set__(self, url)
+        Params:
+            api_key: API key to use for authentication, will default to ORCA_API_KEY if not set.
+            base_url: URL of the OrcaAPI, will default to ORCA_API_URL or the cloud API URL if not set.
+        """
+        logging.getLogger("httpx").setLevel(log_level)
+        logging.getLogger("httpcore").setLevel(log_level)
+        super().__init__(
+            headers={"Api-Key": api_key or os.environ.get("ORCA_API_KEY", "")} | dict(Headers(headers or {}).items()),
+            http1=http1,
+            http2=http2,
+            proxy=proxy,
+            timeout=timeout or Timeout(connect=3, read=20, write=10, pool=5),
+            follow_redirects=True,
+            limits=limits or Limits(max_connections=100, max_keepalive_connections=20),
+            max_redirects=max_redirects,
+            event_hooks=event_hooks
+            or {"request": [self._instrument_request], "response": [self._raise_error_for_response]},
+            base_url=base_url or os.environ.get("ORCA_API_URL", "https://api.orcadb.ai/"),
+            transport=transport
+            or RetryTransport(
+                transport=HTTPTransport(),
+                retry=Retry(
+                    total=5,
+                    backoff_factor=0.5,
+                    allowed_methods=["GET", "POST", "PUT", "PATCH", "DELETE"],
+                    status_forcelist=[429, 500, 502, 503, 504],
+                ),
+            ),
+        )
 
     @property
-    def headers(self) -> Headers:
-        # lazy init headers from environment variable
-        if not self._headers.get("Api-Key"):
-            Client.headers.__set__(self, Headers({"Api-Key": os.environ.get("ORCA_API_KEY", "")}))
-        return self._headers
-
-    @headers.setter
-    def headers(self, headers: HeaderTypes) -> None:
-        Client.headers.__set__(self, headers)
-
-
-def _read_json_response(response: Response) -> dict[str, Any]:
-    content = response.read()
-    text = content.decode(response.encoding or "utf-8")
-    return json.loads(text)
-
-
-def _raise_error_for_response(response: Response) -> None:
-    if response.status_code == 401:
-        raise ValueError("Invalid API key")
-    # elif response.status_code == 402:
-    #     res = cast(QuotaExceededErrorResponse, _read_json_response(response))
-    #     raise RuntimeError(
-    #         f"{res['quota_type'].replace('_', ' ').title()} limit reached ({res['current']}/{res['quota_limit']})"
-    #     )
-    elif response.status_code == 403:
-        raise PermissionError(_read_json_response(response)["reason"])
-    elif response.status_code == 404:
-        res = cast(NotFoundErrorResponse, _read_json_response(response))
-        if res["resource"] is not None:
-            raise LookupError(f"The {res['resource']} you are looking for does not exist")
-        else:
-            raise RuntimeError(f"Unknown API route: {response.url}")
-    elif response.status_code == 405:
-        raise RuntimeError(f"Unknown method {response.request.method} for API route: {response.url}")
-    elif response.status_code == 409:
-        res = cast(ConstraintViolationErrorResponse, _read_json_response(response))
-        raise RuntimeError(res["constraint"])
-    elif response.status_code == 422:
-        res = cast(InvalidInputErrorResponse, _read_json_response(response))
-        issues = [f"{issue['loc'][-1]}: {issue['msg']}" for issue in res["validation_issues"]]
-        raise ValueError("Invalid input:\n\t" + "\n\t".join(issues))
-    elif response.status_code == 500:
-        res = cast(InternalServerErrorResponse, _read_json_response(response))
-        raise RuntimeError(f"Unexpected server error: {res['message']}")
-    elif response.status_code == 503:
-        raise RuntimeError("Orca API is currently unavailable, please try again later")
-    elif response.status_code >= 400:
-        raise RuntimeError(f"Unexpected status code: {response.status_code}")
-
-
-def _instrument_request(request: Request) -> None:
-    request.headers["X-Request-ID"] = str(uuid.uuid4())
-
-
-logging.getLogger("httpx").setLevel(logging.WARNING)
-logging.getLogger("httpcore").setLevel(logging.ERROR)
-
-orca_api = OrcaClient(
-    transport=RetryTransport(
-        transport=HTTPTransport(),
-        retry=Retry(
-            total=5,
-            backoff_factor=0.5,
-            allowed_methods=["GET", "POST", "PUT", "PATCH", "DELETE"],
-            status_forcelist=[429, 500, 502, 503, 504],
-        ),
-    ),
-    event_hooks={"request": [_instrument_request], "response": [_raise_error_for_response]},
-    follow_redirects=True,
-    timeout=Timeout(connect=3, read=20, write=10, pool=5),
-)
-"""Typed client for the Orca API"""
+    def api_key(self) -> str:
+        return self.headers["Api-Key"]
+
+    @api_key.setter
+    def api_key(self, api_key: str) -> None:
+        self.headers.update(Headers({"Api-Key": api_key}))
+
+    client_ctx = ContextVar[Self | None]("orca_client", default=None)
+    default_client: Self | None = None
+
+    @contextmanager
+    def use(self) -> Generator[None, None, None]:
+        """Context manager to inject this client into any OrcaSDK methods"""
+        token = self.client_ctx.set(self)
+        try:
+            yield
+        finally:
+            self.client_ctx.reset(token)
+
+    @classmethod
+    def _resolve_client(cls, client: Self | None = None) -> Self:
+        client = client or cls.client_ctx.get() or cls.default_client
+        if not client:
+            client = cls.default_client = cls()
+        return client