beamlit 0.0.28rc24__py3-none-any.whl → 0.0.29rc26__py3-none-any.whl

beamlit/api/default/get_trace_logs.py

@@ -0,0 +1,186 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.get_trace_logs_response_200 import GetTraceLogsResponse200
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    trace_id: str,
+    *,
+    span_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["spanId"] = span_id
+
+    params["limit"] = limit
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/traces/{trace_id}/logs",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[GetTraceLogsResponse200]:
+    if response.status_code == 200:
+        response_200 = GetTraceLogsResponse200.from_dict(response.json())
+
+        return response_200
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[GetTraceLogsResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    trace_id: str,
+    *,
+    client: AuthenticatedClient,
+    span_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, str] = UNSET,
+) -> Response[GetTraceLogsResponse200]:
+    """Get trace logs
+
+    Args:
+        trace_id (str):
+        span_id (Union[Unset, str]):
+        limit (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[GetTraceLogsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        trace_id=trace_id,
+        span_id=span_id,
+        limit=limit,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    trace_id: str,
+    *,
+    client: AuthenticatedClient,
+    span_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, str] = UNSET,
+) -> Optional[GetTraceLogsResponse200]:
+    """Get trace logs
+
+    Args:
+        trace_id (str):
+        span_id (Union[Unset, str]):
+        limit (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        GetTraceLogsResponse200
+    """
+
+    return sync_detailed(
+        trace_id=trace_id,
+        client=client,
+        span_id=span_id,
+        limit=limit,
+    ).parsed
+
+
+async def asyncio_detailed(
+    trace_id: str,
+    *,
+    client: AuthenticatedClient,
+    span_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, str] = UNSET,
+) -> Response[GetTraceLogsResponse200]:
+    """Get trace logs
+
+    Args:
+        trace_id (str):
+        span_id (Union[Unset, str]):
+        limit (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[GetTraceLogsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        trace_id=trace_id,
+        span_id=span_id,
+        limit=limit,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    trace_id: str,
+    *,
+    client: AuthenticatedClient,
+    span_id: Union[Unset, str] = UNSET,
+    limit: Union[Unset, str] = UNSET,
+) -> Optional[GetTraceLogsResponse200]:
+    """Get trace logs
+
+    Args:
+        trace_id (str):
+        span_id (Union[Unset, str]):
+        limit (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        GetTraceLogsResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            trace_id=trace_id,
+            client=client,
+            span_id=span_id,
+            limit=limit,
+        )
+    ).parsed

beamlit/api/functions/get_function_trace_ids.py

@@ -0,0 +1,106 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    function_name: str,
+    *,
+    environment: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["environment"] = environment
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/functions/{function_name}/traces",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Any]:
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    function_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[Any]:
+    """Get function trace IDs
+
+    Args:
+        function_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        function_name=function_name,
+        environment=environment,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    function_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[Any]:
+    """Get function trace IDs
+
+    Args:
+        function_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        function_name=function_name,
+        environment=environment,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)

beamlit/api/models/get_model_trace_ids.py

@@ -0,0 +1,106 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    model_name: str,
+    *,
+    environment: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["environment"] = environment
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/models/{model_name}/traces",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Any]:
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    model_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[Any]:
+    """Get model trace IDs
+
+    Args:
+        model_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        model_name=model_name,
+        environment=environment,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    model_name: str,
+    *,
+    client: AuthenticatedClient,
+    environment: Union[Unset, str] = UNSET,
+) -> Response[Any]:
+    """Get model trace IDs
+
+    Args:
+        model_name (str):
+        environment (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        model_name=model_name,
+        environment=environment,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)

beamlit/authentication/authentication.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from typing import Dict, Generator
+import os
 
 from httpx import Auth, Request, Response
 
@@ -26,8 +27,13 @@ class PublicProvider(Auth):
 class RunClientWithCredentials:
     credentials: Credentials
     workspace: str
-    api_url: str = "https://api.beamlit.dev/v0"
-    run_url: str = "https://run.beamlit.dev/v0"
+    api_url: str = "https://api.beamlit.com/v0"
+    run_url: str = "https://run.beamlit.com/v0"
+
+    def __post_init__(self):
+        if os.getenv('BL_ENV') == 'dev':
+            self.api_url = "https://api.beamlit.dev/v0"
+            self.run_url = "https://run.beamlit.dev/v0"
 
 
 def new_client_from_settings(settings: Settings):
@@ -41,15 +47,15 @@ def new_client_from_settings(settings: Settings):
 
 
 def new_client():
+    settings = get_settings()
     context = current_context()
-    if context.workspace:
+    if context.workspace and not settings.authentication.client.credentials:
         credentials = load_credentials(context.workspace)
         client_config = RunClientWithCredentials(
             credentials=credentials,
             workspace=context.workspace,
         )
     else:
-        settings = get_settings()
         credentials = load_credentials_from_settings(settings)
         client_config = RunClientWithCredentials(
             credentials=credentials,

beamlit/authentication/clientcredentials.py

@@ -37,7 +37,7 @@ class ClientCredentials(Auth):
     def refresh_if_needed(self) -> Optional[Exception]:
         settings = get_settings()
         if self.credentials.client_credentials and not self.credentials.refresh_token:
-            headers = {"Authorization": f"Basic {self.credentials.client_credentials}"}
+            headers = {"Authorization": f"Basic {self.credentials.client_credentials}", "Content-Type": "application/json"}
             body = {"grant_type": "client_credentials"}
             response = requests.post(f"{settings.base_url}/oauth/token", headers=headers, json=body)
             response.raise_for_status()

beamlit/client.py

@@ -1,3 +1,4 @@
+import os
 import ssl
 from typing import Any, Optional, Union
 
@@ -37,8 +38,13 @@ class Client:
 
     """
 
+    # Determine the base URL based on the environment
+    default_base_url = "https://api.beamlit.com/v0"
+    if os.getenv("BL_ENV") == "dev":
+        default_base_url = "https://api.beamlit.dev/v0"
+
     raise_on_unexpected_status: bool = field(default=True, kw_only=True)
-    _base_url: str = field(alias="base_url", default="https://api.beamlit.dev/v0")
+    _base_url: str = field(alias="base_url", default=default_base_url)
     _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
     _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
     _provider: httpx.Auth = field(default=None, alias="provider")
@@ -169,8 +175,13 @@ class AuthenticatedClient:
         provider: AuthProvider to use for authentication
     """
 
+    # Determine the base URL based on the environment
+    default_base_url = "https://api.beamlit.com/v0"
+    if os.getenv("BL_ENV") == "dev":
+        default_base_url = "https://api.beamlit.dev/v0"
+
     raise_on_unexpected_status: bool = field(default=True, kw_only=True)
-    _base_url: str = field(alias="base_url", default="https://api.beamlit.dev/v0")
+    _base_url: str = field(alias="base_url", default=default_base_url)
     _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
     _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
     _provider: httpx.Auth = field(default=None, alias="provider")

beamlit/common/settings.py

@@ -18,11 +18,6 @@ from pydantic_settings import (BaseSettings, PydanticBaseSettingsSource,
 global SETTINGS
 SETTINGS = None
 
-
-def get_settings():
-    return SETTINGS
-
-
 class SettingsAgent(BaseSettings):
     agent: Union[None, CompiledGraph, BaseChatModel] = None
     chain: Union[Unset, list[Agent]] = UNSET
@@ -62,15 +57,23 @@ class Settings(BaseSettings):
     remote: bool = Field(default=False)
     type: str = Field(default="agent")
     name: str = Field(default="beamlit-agent")
-    base_url: str = Field(default="https://api.beamlit.dev/v0")
-    run_url: str = Field(default="https://run.beamlit.dev")
-    mcp_hub_url: str = Field(default="https://mcp-hub-server.beamlit.workers.dev")
-    registry_url: str = Field(default="https://serverless-registry-production.beamlit.workers.dev")
+    base_url: str = Field(default="https://api.beamlit.com/v0")
+    run_url: str = Field(default="https://run.beamlit.com")
+    mcp_hub_url: str = Field(default="https://mcp-hub-server.beamlit.workers.com")
+    registry_url: str = Field(default="https://serverless-registry-production.beamlit.workers.com")
     log_level: str = Field(default="INFO")
     agent: SettingsAgent = SettingsAgent()
     server: SettingsServer = SettingsServer()
     authentication: SettingsAuthentication = SettingsAuthentication()
 
+    def __init__(self, **data):
+        super().__init__(**data)
+        if os.getenv('BL_ENV') == 'dev':
+            self.base_url = "https://api.beamlit.dev/v0"
+            self.run_url = "https://run.beamlit.dev"
+            self.mcp_hub_url = "https://mcp-hub-server.beamlit.workers.dev"
+            self.registry_url = "https://serverless-registry-production.beamlit.workers.dev"
+
     @classmethod
     def settings_customise_sources(
         cls,
@@ -88,6 +91,9 @@ class Settings(BaseSettings):
             init_settings,
         )
 
+def get_settings() -> Settings:
+    return SETTINGS
+
 
 def init_agent(
     client: AuthenticatedClient,

beamlit/functions/remote/remote.py

@@ -1,20 +1,21 @@
 import asyncio
-import urllib.parse
 import warnings
 from typing import Any, Callable
 
 import pydantic
-import pydantic_core
 import typing_extensions as t
+from dataclasses import dataclass
 from beamlit.api.functions import get_function
 from beamlit.authentication.authentication import AuthenticatedClient
-from beamlit.models.function import Function
-from langchain_core.tools.base import BaseTool, BaseToolkit, ToolException
+from beamlit.run import RunClient
+from beamlit.common.settings import get_settings
+from beamlit.models import Function, StoreFunctionParameter
+from langchain_core.tools.base import BaseTool, ToolException
 from pydantic.json_schema import JsonSchemaValue
 from pydantic_core import core_schema as cs
 
 
-def create_schema_model(schema: dict[str, t.Any]) -> type[pydantic.BaseModel]:
+def create_schema_model(parameters: list[StoreFunctionParameter]) -> type[pydantic.BaseModel]:
     # Create a new model class that returns our JSON schema.
     # LangChain requires a BaseModel class.
     class Schema(pydantic.BaseModel):
@@ -25,6 +26,18 @@ def create_schema_model(schema: dict[str, t.Any]) -> type[pydantic.BaseModel]:
         def __get_pydantic_json_schema__(
             cls, core_schema: cs.CoreSchema, handler: pydantic.GetJsonSchemaHandler
         ) -> JsonSchemaValue:
+            schema = {
+                "type": "object",
+                "properties": {},
+                "required": [],
+            }
+            for parameter in parameters:
+                schema["properties"][parameter.name] = {
+                    "type": parameter.type_,
+                    "description": parameter.description,
+                }
+                if parameter.required:
+                    schema["required"].append(parameter.name)
             return schema
 
     return Schema
@@ -35,7 +48,7 @@ class RemoteTool(BaseTool):
     Remote tool
     """
 
-    client: AuthenticatedClient
+    client: RunClient
     handle_tool_error: bool | str | Callable[[ToolException], str] | None = True
 
     @t.override
@@ -48,12 +61,15 @@ class RemoteTool(BaseTool):
 
     @t.override
     async def _arun(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
-        result = self.client.call_tool(self.name, arguments=kwargs)
-        response = result.json()
-        content = pydantic_core.to_json(response["content"]).decode()
-        if response["isError"]:
-            raise ToolException(content)
-        return content
+        settings = get_settings()
+        result = self.client.run(
+            "function",
+            self.name,
+            settings.environment,
+            "POST",
+            kwargs,
+        )
+        return result.text
 
     @t.override
     @property
@@ -61,7 +77,8 @@ class RemoteTool(BaseTool):
         assert self.args_schema is not None  # noqa: S101
         return self.args_schema
 
-class RemoteToolkit(BaseToolkit):
+@dataclass
+class RemoteToolkit:
     """
     Remote toolkit
     """
@@ -75,27 +92,27 @@ class RemoteToolkit(BaseToolkit):
     def initialize(self) -> None:
         """Initialize the session and retrieve tools list"""
         if self._function is None:
-            self._function = get_function(self.function, client=self.client)
+            self._function = get_function.sync_detailed(self.function, client=self.client).parsed
 
     @t.override
     def get_tools(self) -> list[BaseTool]:
-        if self._tools is None:
+        if self._function is None:
             raise RuntimeError("Must initialize the toolkit first")
 
         if self._function.spec.kit:
             return [
                 RemoteTool(
-                client=self.client,
-                name=func.name,
-                description=func.description or "",
-                args_schema=create_schema_model(func.parameters),
+                    client=RunClient(self.client),
+                    name=func.name,
+                    description=func.description or "",
+                    args_schema=create_schema_model(func.parameters),
                 )
                 for func in self._function.spec.kit
             ]
 
         return [
             RemoteTool(
-                client=self.client,
+                client=RunClient(self.client),
                 name=self._function.metadata.name,
                 description=self._function.spec.description or "",
                 args_schema=create_schema_model(self._function.spec.parameters),

beamlit/models/__init__.py

@@ -29,6 +29,9 @@ from .function_kit import FunctionKit
 from .function_metadata import FunctionMetadata
 from .function_release import FunctionRelease
 from .function_spec import FunctionSpec
+from .get_trace_ids_response_200 import GetTraceIdsResponse200
+from .get_trace_logs_response_200 import GetTraceLogsResponse200
+from .get_trace_response_200 import GetTraceResponse200
 from .get_workspace_service_accounts_response_200_item import GetWorkspaceServiceAccountsResponse200Item
 from .increase_and_rate_metric import IncreaseAndRateMetric
 from .integration_config import IntegrationConfig
@@ -128,6 +131,9 @@ __all__ = (
     "FunctionMetadata",
     "FunctionRelease",
     "FunctionSpec",
+    "GetTraceIdsResponse200",
+    "GetTraceLogsResponse200",
+    "GetTraceResponse200",
     "GetWorkspaceServiceAccountsResponse200Item",
     "IncreaseAndRateMetric",
     "IntegrationConfig",