haystack-enterprise-sdk 0.1.2__tar.gz → 0.2.0__tar.gz

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haystack-enterprise-sdk
-Version: 0.1.2
+Version: 0.2.0
 Summary: Python SDK and CLI for the Haystack Enterprise Platform
 Keywords: agents,deepset,haystack,llm,pipelines,rag,sdk
 Author: deepset.ai
@@ -145,14 +145,14 @@ A deployed service is served over an OpenAI-compatible chat-completions endpoint
 once the service is running:
 
 ```bash
-curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/<deployment-id>/chat/completions \
+curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/v1/chat/completions \
   -H "Authorization: Bearer $API_KEY" \
   -H "Content-Type: application/json" \
-  -d '{"model": "<workspace>/<service-name>", "messages": [{"role": "user", "content": "Hello"}]}'
+  -d '{"model": "<workspace>/<deployment-id>", "messages": [{"role": "user", "content": "Hello"}]}'
 ```
 
 The response is a server-sent-event stream of `chat.completion.chunk` objects. Any OpenAI client works —
-point its `base_url` at everything up to and including `/deployments/<deployment-id>`.
+point its `base_url` at everything up to and including `/deployments/v1`.
 
 Pass `--verbose` to any command for INFO/DEBUG logs, and `<command> --help` for its arguments.
 

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/README.md

@@ -100,14 +100,14 @@ A deployed service is served over an OpenAI-compatible chat-completions endpoint
 once the service is running:
 
 ```bash
-curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/<deployment-id>/chat/completions \
+curl -N https://api.cloud.deepset.ai/api/v1/workspaces/<workspace>/deployments/v1/chat/completions \
   -H "Authorization: Bearer $API_KEY" \
   -H "Content-Type: application/json" \
-  -d '{"model": "<workspace>/<service-name>", "messages": [{"role": "user", "content": "Hello"}]}'
+  -d '{"model": "<workspace>/<deployment-id>", "messages": [{"role": "user", "content": "Hello"}]}'
 ```
 
 The response is a server-sent-event stream of `chat.completion.chunk` objects. Any OpenAI client works —
-point its `base_url` at everything up to and including `/deployments/<deployment-id>`.
+point its `base_url` at everything up to and including `/deployments/v1`.
 
 Pass `--verbose` to any command for INFO/DEBUG logs, and `<command> --help` for its arguments.
 

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/README.md

@@ -1,4 +1,4 @@
-# Software development kit for the deepset API
+# Software design
 
 This package is split into multiple layers:
 - API layer

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/_api/deployments.py

@@ -10,7 +10,7 @@ list endpoint and matching client-side.
 
 import asyncio
 import enum
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Type, TypeVar
 from uuid import UUID
 
@@ -97,6 +97,10 @@ class Deployment:
     # revision, so it stays None until a revision is activated. This is the platform's own answer to
     # "is this a chat pipeline?" -- the CLI reads it rather than guessing from components or sockets.
     output_type: Optional[PipelineOutputType] = None
+    # Free-form labels, capped server-side at MAX_SERVICE_TAGS (3). Not settable at creation --
+    # the platform has no `tags` field on its create-deployment request, only the dedicated
+    # add/remove-tag endpoints below, so this always reflects a create followed by N tag calls.
+    tags: List[str] = field(default_factory=list)
 
     @classmethod
     def from_response(cls, body: Dict[str, Any]) -> "Deployment":
@@ -120,6 +124,7 @@ class Deployment:
             # The platform enum has values this SDK does not model (e.g. "unknown"), and the field is
             # absent until a revision is active, so anything unrecognized degrades to None.
             output_type=_enum_or_none(PipelineOutputType, body.get("output_type")),
+            tags=list(body.get("tags") or []),
         )
 
 
@@ -244,6 +249,15 @@ class FailedToActivateRevisionError(Exception):
     """Raised when a deployment revision could not be activated."""
 
 
+class FailedToTagDeploymentError(Exception):
+    """Raised when a tag could not be added to, or removed from, a deployment.
+
+    Covers the platform's own rejections too: a name over 50 chars or outside
+    ``[A-Za-z0-9 _-]``, a duplicate (case-insensitive), or a fourth tag past MAX_SERVICE_TAGS (3)
+    all come back as a 4xx from the tag endpoints, not just a network/auth failure.
+    """
+
+
 class FailedToValidatePipelineError(Exception):
     """Raised when the validation request itself failed (e.g. auth/5xx), not the pipeline config."""
 
@@ -453,6 +467,50 @@ class DeploymentsAPI:
         )
         return Deployment.from_response(response.json())
 
+    async def add_tag(self, workspace_name: str, deployment_id: UUID, tag_name: str) -> List[str]:
+        """Add a tag to a deployment.
+
+        :param workspace_name: Name of the workspace.
+        :param deployment_id: Deployment id.
+        :param tag_name: Tag name (1-50 chars; letters, digits, spaces, underscores, hyphens).
+            Rejected as a duplicate case-insensitively, and past the third tag on one deployment.
+        :raises FailedToTagDeploymentError: If the tag could not be added.
+        :return: The deployment's full tag list after the add.
+        """
+        response = await self._haystack_enterprise_api.post(
+            workspace_name=workspace_name,
+            endpoint=f"{self._ENDPOINT}/{deployment_id}/tags",
+            json={"name": tag_name},
+        )
+        raise_for_unexpected_status(
+            response,
+            (codes.OK,),
+            FailedToTagDeploymentError,
+            f"Failed to add tag {tag_name!r} to deployment '{deployment_id}'.",
+        )
+        return list(response.json())
+
+    async def remove_tag(self, workspace_name: str, deployment_id: UUID, tag_name: str) -> List[str]:
+        """Remove a tag from a deployment. Matching is case-insensitive.
+
+        :param workspace_name: Name of the workspace.
+        :param deployment_id: Deployment id.
+        :param tag_name: Tag name to remove.
+        :raises FailedToTagDeploymentError: If the tag could not be removed (including "not found").
+        :return: The deployment's full tag list after the removal.
+        """
+        response = await self._haystack_enterprise_api.delete(
+            workspace_name=workspace_name,
+            endpoint=f"{self._ENDPOINT}/{deployment_id}/tags/{tag_name}",
+        )
+        raise_for_unexpected_status(
+            response,
+            (codes.OK,),
+            FailedToTagDeploymentError,
+            f"Failed to remove tag {tag_name!r} from deployment '{deployment_id}'.",
+        )
+        return list(response.json())
+
     async def validate_pipeline(
         self,
         workspace_name: str,

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/_api/haystack_enterprise_api.py

@@ -148,11 +148,9 @@ def raise_for_unexpected_status(
 
 
 def deployment_base_url(api_url: str, workspace_name: str, deployment_id: Any) -> str:
-    """Build the base URL of a deployment's OpenAI-compatible endpoint.
+    """Build the per-deployment base URL (used for per-deployment routes like ``/chat`` and ``/chat-stream``).
 
-    The platform serves ``POST <this>/chat/completions`` for a deployment with an active revision. It is
-    keyed on the deployment id, not the service name. Returned without the ``/chat/completions`` suffix
-    because that is exactly the ``base_url`` an OpenAI client expects (it appends the path itself).
+    Returned without a trailing path segment because callers append their own route (e.g. ``/chat``).
 
     :param api_url: Base API URL, already normalized (see :func:`~haystack_enterprise_sdk._api.config.normalize_base_url`).
     :param workspace_name: Name of the workspace the deployment lives in.
@@ -162,6 +160,20 @@ def deployment_base_url(api_url: str, workspace_name: str, deployment_id: Any) -
     return f"{api_url}/{API_VERSION_PATH}/workspaces/{workspace_name}/deployments/{deployment_id}"
 
 
+def chat_completions_base_url(api_url: str, workspace_name: str) -> str:
+    """Build the workspace-scoped OpenAI-compatible chat-completions base URL.
+
+    The platform's OpenAI-compatible gateway lives at ``POST <this>/chat/completions``.
+    The ``model`` field must be ``{workspace_name}/{deployment_id}`` (UUID, not service name).
+    Returned without the ``/chat/completions`` suffix so an OpenAI client can use it as ``base_url``.
+
+    :param api_url: Base API URL, already normalized (see :func:`~haystack_enterprise_sdk._api.config.normalize_base_url`).
+    :param workspace_name: Name of the workspace.
+    :return: e.g. ``https://api.cloud.deepset.ai/api/v1/workspaces/my-ws/deployments/v1``.
+    """
+    return f"{api_url}/{API_VERSION_PATH}/workspaces/{workspace_name}/deployments/v1"
+
+
 class HaystackEnterpriseAPI:
     """Haystack Enterprise Platform API client.
 

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/_service/deployment_service.py

@@ -22,6 +22,7 @@ from haystack_enterprise_sdk._api.deployments import (
     DeploymentsAPI,
     DeploymentServiceLevel,
     DeploymentStatus,
+    FailedToTagDeploymentError,
     PipelineValidationError,
     PipelineValidationResult,
 )
@@ -147,6 +148,9 @@ class CreateOptions:
     cpu_limit: Optional[str] = None
     memory_limit: Optional[str] = None
     gpu_limit_gigabyte: Optional[int] = None
+    # Applied with one add_tag call each, right after creation -- the create-deployment endpoint
+    # itself has no `tags` field. Not a sizing field: it applies to serverless services too.
+    tags: Tuple[str, ...] = ()
 
     _SIZING_FIELDS = (
         "service_level",
@@ -493,6 +497,38 @@ class DeploymentService:
             )
         return await self._deployments.get_deployment(self._workspace_name, deployment.deployment_id)
 
+    async def add_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Add a tag to a service by name, independent of deploy/create.
+
+        :param service_name: Name of the service deployment.
+        :param tag_name: Tag name (1-50 chars; letters, digits, spaces, underscores, hyphens).
+        :raises ServiceNotFoundError: If no service with that name exists.
+        :raises FailedToTagDeploymentError: If the platform rejected it (limit, duplicate, bad name).
+        :return: The service's full tag list after the add.
+        """
+        deployment = await self._deployments.find_by_name(self._workspace_name, service_name)
+        if deployment is None:
+            raise ServiceNotFoundError(
+                f"No service deployment named '{service_name}' in workspace '{self._workspace_name}'."
+            )
+        return await self._deployments.add_tag(self._workspace_name, deployment.deployment_id, tag_name)
+
+    async def remove_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Remove a tag from a service by name. Matching is case-insensitive.
+
+        :param service_name: Name of the service deployment.
+        :param tag_name: Tag name to remove.
+        :raises ServiceNotFoundError: If no service with that name exists.
+        :raises FailedToTagDeploymentError: If the tag could not be removed (including "not found").
+        :return: The service's full tag list after the removal.
+        """
+        deployment = await self._deployments.find_by_name(self._workspace_name, service_name)
+        if deployment is None:
+            raise ServiceNotFoundError(
+                f"No service deployment named '{service_name}' in workspace '{self._workspace_name}'."
+            )
+        return await self._deployments.remove_tag(self._workspace_name, deployment.deployment_id, tag_name)
+
     async def create_shared_prototype(
         self, service_name: str, options: Optional[ShareOptions] = None
     ) -> SharedPrototype:
@@ -538,7 +574,7 @@ class DeploymentService:
             )
         options = create_options or CreateOptions()
         logger.info("Creating service deployment.", service=service_name, mode=options.deployment_mode.value)
-        return await self._deployments.create_deployment(
+        deployment = await self._deployments.create_deployment(
             self._workspace_name,
             name=service_name,
             deployment_mode=options.deployment_mode,
@@ -550,6 +586,24 @@ class DeploymentService:
             memory_limit=options.memory_limit,
             gpu_limit_gigabyte=options.gpu_limit_gigabyte,
         )
+        for tag_name in options.tags:
+            # Sequential, not gathered: each call returns the full tag list so far, and the
+            # platform's own duplicate/limit checks are per-request -- gathering could race two
+            # adds past the 3-tag cap. There are at most 3 of these, so latency is not a concern.
+            #
+            # Caught here rather than left to propagate: the service was already created, so raising
+            # would abort a deploy that otherwise fully succeeded. `tag-add` can retry independently.
+            try:
+                deployment.tags = await self._deployments.add_tag(
+                    self._workspace_name, deployment.deployment_id, tag_name
+                )
+            except FailedToTagDeploymentError:
+                logger.warning(
+                    "Failed to add tag to newly created service; retry with 'tag-add'.",
+                    service=service_name,
+                    tag=tag_name,
+                )
+        return deployment
 
     async def _poll_until_settled(
         self,

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/cli.py

@@ -27,6 +27,7 @@ from haystack_enterprise_sdk._api.config import (
 from haystack_enterprise_sdk._api.deployments import (
     DeploymentMode,
     DeploymentServiceLevel,
+    FailedToTagDeploymentError,
     PipelineValidationError,
 )
 from haystack_enterprise_sdk._api.haystack_enterprise_api import HaystackEnterpriseAPIError
@@ -449,6 +450,9 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     memory: Optional[str] = None,
     gpu: Optional[int] = None,
     idle_timeout: Optional[int] = None,
+    tag: Optional[List[str]] = typer.Option(
+        None, "--tag", help="Tag to add when creating the service (repeatable; up to 3)."
+    ),
     python: Optional[str] = None,
     dry_run: bool = False,
     output: Optional[Path] = None,
@@ -492,6 +496,11 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     :param memory: Memory limit, e.g. '2Gi' (with --managed).
     :param gpu: GPU memory limit in gigabytes (with --managed).
     :param idle_timeout: Idle timeout in seconds before scale-down (with --managed).
+    :param tag: Tag to add to the service when it is created (repeatable; the platform allows at
+        most 3 per service). Only applies when the service is created -- pass --create, or omit
+        --create against a service name that does not exist yet. Rejected if the service already
+        exists, same as --managed and the sizing flags -- use `tag-add`/`tag-remove` to change
+        tags on a service after creation.
     :param python: Path to the Python interpreter used to load your pipeline (defaults to an
         auto-detected virtualenv near the target file, else the current interpreter).
     :param dry_run: Transform the pipeline and print/write the resulting YAML without deploying. No
@@ -524,6 +533,9 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     Create a managed service with explicit sizing (activates and waits for the rollout):
     `haystack-enterprise deploy pipeline.py my-service --managed --service-level PRODUCTION --cpu 2`
 
+    Create a service tagged for a team and a hackathon, up to 3 tags:
+    `haystack-enterprise deploy pipeline.py my-service --create --tag team-success --tag hackathon`
+
     Describe the revision instead of using the auto-generated comment:
     `haystack-enterprise deploy pipeline.py my-service -m "Bump embedder model to bge-large"`
 
@@ -575,8 +587,8 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
     if create is False and existing is None:
         typer.echo(f"No service named '{service_name}' in workspace '{workspace_name}'. Drop --no-create to create it.")
         raise typer.Exit(1)
-    if existing is not None and (managed or given_sizing):
-        creation_flags = (["--managed"] if managed else []) + given_sizing
+    if existing is not None and (managed or given_sizing or tag):
+        creation_flags = (["--managed"] if managed else []) + given_sizing + (["--tag"] if tag else [])
         applies = "only applies" if len(creation_flags) == 1 else "only apply"
         typer.echo(
             f"Service '{service_name}' already exists; {', '.join(creation_flags)} {applies} when a "
@@ -596,9 +608,10 @@ def deploy(  # pylint: disable=too-many-arguments,too-many-locals
             cpu_limit=cpu,
             memory_limit=memory,
             gpu_limit_gigabyte=gpu,
+            tags=tuple(tag or ()),
         )
     else:
-        create_options = CreateOptions(deployment_mode=DeploymentMode.SERVERLESS)
+        create_options = CreateOptions(deployment_mode=DeploymentMode.SERVERLESS, tags=tuple(tag or ()))
 
     activate = not skip_activation
 
@@ -1152,8 +1165,8 @@ def _echo_endpoint(client: DeploymentClient, service_name: str, result: DeployRe
     if not result.is_deployed:
         return
 
-    base_url = client.deployment_base_url(result.deployment.deployment_id)
-    model = f"{client.workspace_name}/{service_name}"
+    base_url = client.chat_completions_base_url()
+    model = f"{client.workspace_name}/{result.deployment.deployment_id}"
     typer.echo(f"\nChat completions endpoint (OpenAI-compatible):\n  POST {base_url}/chat/completions")
     typer.echo(
         f"\n  curl -N {base_url}/chat/completions \\\n"
@@ -1649,12 +1662,70 @@ def service_status(
                 "pending_revision_id": (
                     str(deployment.pending_revision_id) if deployment.pending_revision_id else None
                 ),
+                "tags": deployment.tags,
             },
             indent=4,
         )
     )
 
 
+@cli_app.command()
+def tag_add(
+    service_name: str,
+    tag_name: str,
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    workspace_name: str = DEFAULT_WORKSPACE_NAME,
+) -> None:
+    """Add a tag to a service deployment, independent of deploy/create.
+
+    :param service_name: Name of the service deployment.
+    :param tag_name: Tag name (1-50 chars; letters, digits, spaces, underscores, hyphens).
+        Rejected as a duplicate case-insensitively, and past the third tag on one service.
+    :param api_key: deepset API key to use for authentication.
+    :param api_url: API URL to use for authentication.
+    :param workspace_name: Workspace of the service. Uses the workspace from the .ENV file by default.
+
+    Example:
+    `haystack-enterprise tag-add my-service hackathon`
+    """
+    client = DeploymentClient(api_key=api_key, api_url=api_url, workspace_name=workspace_name)
+    try:
+        tags = client.add_tag(service_name, tag_name)
+    except (ServiceNotFoundError, FailedToTagDeploymentError) as err:
+        typer.echo(str(err))
+        raise typer.Exit(1)  # noqa: B904
+    typer.echo(f"Tags on '{service_name}': {', '.join(tags) or '(none)'}")
+
+
+@cli_app.command()
+def tag_remove(
+    service_name: str,
+    tag_name: str,
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    workspace_name: str = DEFAULT_WORKSPACE_NAME,
+) -> None:
+    """Remove a tag from a service deployment. Matching is case-insensitive.
+
+    :param service_name: Name of the service deployment.
+    :param tag_name: Tag name to remove.
+    :param api_key: deepset API key to use for authentication.
+    :param api_url: API URL to use for authentication.
+    :param workspace_name: Workspace of the service. Uses the workspace from the .ENV file by default.
+
+    Example:
+    `haystack-enterprise tag-remove my-service hackathon`
+    """
+    client = DeploymentClient(api_key=api_key, api_url=api_url, workspace_name=workspace_name)
+    try:
+        tags = client.remove_tag(service_name, tag_name)
+    except (ServiceNotFoundError, FailedToTagDeploymentError) as err:
+        typer.echo(str(err))
+        raise typer.Exit(1)  # noqa: B904
+    typer.echo(f"Tags on '{service_name}': {', '.join(tags) or '(none)'}")
+
+
 def version_callback(value: bool) -> None:
     """Show the SDK version and exit.
 

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/workflows/async_client/deployment_client.py

@@ -19,6 +19,7 @@ from haystack_enterprise_sdk._api.deployments import (
 )
 from haystack_enterprise_sdk._api.haystack_enterprise_api import (
     HaystackEnterpriseAPI,
+    chat_completions_base_url,
     deployment_base_url,
 )
 from haystack_enterprise_sdk._api.pipeline_run import DEFAULT_RUN_RETRIES, OnRetry
@@ -76,16 +77,23 @@ class AsyncDeploymentClient:
         return self._workspace_name
 
     def deployment_base_url(self, deployment_id: Any) -> str:
-        """The OpenAI-compatible base URL of a deployment in this client's workspace.
-
-        Append ``/chat/completions`` to call it directly, or hand it to an OpenAI client as ``base_url``.
-        Only usable once the deployment has an active revision.
+        """The per-deployment base URL (for per-deployment routes like ``/chat`` and ``/chat-stream``).
 
         :param deployment_id: Id of the deployment (e.g. ``DeployResult.deployment.deployment_id``).
         :return: The deployment's base URL.
         """
         return deployment_base_url(self._api_config.api_url, self._workspace_name, deployment_id)
 
+    def chat_completions_base_url(self) -> str:
+        """The workspace-scoped OpenAI-compatible base URL for chat completions.
+
+        Use ``POST <this>/chat/completions`` with ``model`` set to ``{workspace}/{deployment_id}`` (UUID).
+        Pass this as ``base_url`` to an OpenAI client.
+
+        :return: e.g. ``https://api.cloud.deepset.ai/api/v1/workspaces/my-ws/deployments/v1``.
+        """
+        return chat_completions_base_url(self._api_config.api_url, self._workspace_name)
+
     @asynccontextmanager
     async def _service(self) -> AsyncIterator[DeploymentService]:
         """Yield a :class:`DeploymentService` backed by a managed API client."""
@@ -210,6 +218,20 @@ class AsyncDeploymentClient:
         async with self._service() as service:
             return await service.get_service_status(service_name)
 
+    async def add_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Add a tag to a service by name, independent of deploy/create. See
+        :meth:`haystack_enterprise_sdk._service.deployment_service.DeploymentService.add_tag`.
+        """
+        async with self._service() as service:
+            return await service.add_tag(service_name, tag_name)
+
+    async def remove_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Remove a tag from a service by name. See
+        :meth:`haystack_enterprise_sdk._service.deployment_service.DeploymentService.remove_tag`.
+        """
+        async with self._service() as service:
+            return await service.remove_tag(service_name, tag_name)
+
     async def create_shared_prototype(
         self, service_name: str, options: Optional[ShareOptions] = None
     ) -> SharedPrototype:

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/haystack_enterprise_sdk/workflows/sync_client/deployment_client.py

@@ -183,6 +183,14 @@ class DeploymentClient:  # pylint: disable=too-few-public-methods
         """Return the current deployment (with live runtime status) for ``service_name``."""
         return _run(self._async_client.get_service_status(service_name))
 
+    def add_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Add a tag to a service by name, independent of deploy/create, synchronously."""
+        return _run(self._async_client.add_tag(service_name, tag_name))
+
+    def remove_tag(self, service_name: str, tag_name: str) -> List[str]:
+        """Remove a tag from a service by name synchronously."""
+        return _run(self._async_client.remove_tag(service_name, tag_name))
+
     def create_shared_prototype(self, service_name: str, options: Optional[ShareOptions] = None) -> SharedPrototype:
         """Create a shared prototype (a shareable chat UI link) for a deployed service synchronously."""
         return _run(self._async_client.create_shared_prototype(service_name, options))
@@ -193,5 +201,9 @@ class DeploymentClient:  # pylint: disable=too-few-public-methods
         return self._async_client.workspace_name
 
     def deployment_base_url(self, deployment_id: Any) -> str:
-        """The OpenAI-compatible base URL of a deployment. See :meth:`AsyncDeploymentClient.deployment_base_url`."""
+        """The per-deployment base URL. See :meth:`AsyncDeploymentClient.deployment_base_url`."""
         return self._async_client.deployment_base_url(deployment_id)
+
+    def chat_completions_base_url(self) -> str:
+        """The workspace-scoped chat-completions base URL. See :meth:`AsyncDeploymentClient.chat_completions_base_url`."""
+        return self._async_client.chat_completions_base_url()

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "haystack-enterprise-sdk"
-version = "0.1.2"
+version = "0.2.0"
 description = "Python SDK and CLI for the Haystack Enterprise Platform"
 readme = "README.md"
 requires-python = ">=3.10"

{haystack_enterprise_sdk-0.1.2 → haystack_enterprise_sdk-0.2.0}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "haystack-enterprise-sdk"
-version = "0.1.2"
+version = "0.2.0"
 description = "Python SDK and CLI for the Haystack Enterprise Platform"
 readme = "README.md"
 requires-python = ">=3.10"