databricks-mason 0.1.0.dev0__tar.gz → 0.1.2.dev0__tar.gz

databricks_mason-0.1.2.dev0/NOTICE

@@ -0,0 +1,39 @@
+Copyright (c) 2026 Databricks, Inc. All rights reserved.
+
+This Software is the property of Databricks, Inc. ("Databricks") and no license, right, or authorization to install, use, copy, modify, or distribute this Software is granted except pursuant to Databricks' prior written authorization. Any use of this Software without such written authorization from Databricks is strictly prohibited.
+
+# MIT License
+
+This Software contains code from the following open source projects, licensed under the MIT license (https://opensource.org/licenses/MIT).
+
+Package: PyYAML
+Project URL: https://github.com/yaml/pyyaml
+Copyright: 2017-2021 Ingy döt Net, 2006-2016 Kirill Simonov
+
+Package: rich
+Project URL: https://github.com/Textualize/rich
+Copyright: 2020 Will McGugan
+
+Package: tomli
+Project URL: https://github.com/hukkin/tomli
+Copyright: 2021 Taneli Hukkinen
+
+Package: tomlkit
+Project URL: https://github.com/python-poetry/tomlkit
+Copyright: 2018 Sébastien Eustace
+
+# Apache License 2.0
+
+This Software contains code from the following open source projects, licensed under the Apache License 2.0 license (https://www.apache.org/licenses/LICENSE-2.0).
+
+Package: databricks-sdk
+Project URL: https://github.com/databricks/databricks-sdk-py
+Copyright: 2023 Databricks, Inc.
+
+# BSD 3-Clause License
+
+This Software contains code from the following open source projects, licensed under the BSD 3-Clause License (https://opensource.org/license/bsd-3-clause).
+
+Package: click
+Project URL: https://github.com/pallets/click
+Copyright: 2014 Pallets

databricks_mason-0.1.2.dev0/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.5
+Name: databricks-mason
+Version: 0.1.2.dev0
+Summary: Databricks integration for Mason
+Author-email: Databricks <agent-feedback@databricks.com>
+License-File: NOTICE
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Requires-Dist: databricks-sdk>=0.49
+Requires-Dist: psycopg[binary]>=3.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: tomli>=2.0
+Requires-Dist: tomlkit>=0.13
+Provides-Extra: runtime
+Requires-Dist: databricks-agents>=1.9.3; extra == 'runtime'
+Requires-Dist: databricks-langchain>=0.17.0; extra == 'runtime'
+Requires-Dist: fastapi>=0.129.0; extra == 'runtime'
+Requires-Dist: langchain-mcp-adapters>=0.2.1; extra == 'runtime'
+Requires-Dist: langchain>=1.0.0; extra == 'runtime'
+Requires-Dist: langgraph>=1.1.0; extra == 'runtime'
+Requires-Dist: mlflow>=3.10.1; extra == 'runtime'
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.25.0; extra == 'runtime'
+Requires-Dist: uuid-utils>=0.10.0; extra == 'runtime'
+Provides-Extra: runtime-openai
+Requires-Dist: databricks-agents>=1.9.3; extra == 'runtime-openai'
+Requires-Dist: databricks-openai>=0.13.0; extra == 'runtime-openai'
+Requires-Dist: fastapi>=0.129.0; extra == 'runtime-openai'
+Requires-Dist: mlflow>=3.10.1; extra == 'runtime-openai'
+Requires-Dist: openai-agents>=0.4.1; extra == 'runtime-openai'
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.25.0; extra == 'runtime-openai'
+Requires-Dist: uuid-utils>=0.10.0; extra == 'runtime-openai'
+Provides-Extra: tracing
+Requires-Dist: mlflow[databricks]>=3.9.0; extra == 'tracing'
+Description-Content-Type: text/markdown
+
+# `databricks-mason`
+
+Mason is an experimental CLI for Databricks custom agent preview APIs and
+deployments. It manages memory, sessions, tracing, and deployments from one
+authenticated command.
+
+> The underlying APIs are in preview and may need workspace enablement.
+
+## Installation
+
+From PyPI:
+
+```sh
+pip install databricks-mason
+```
+
+From source:
+
+```sh
+pip install 'git+https://github.com/databricks/databricks-ai-bridge.git#subdirectory=integrations/mason'
+```
+
+For tracing commands, install Mason with tracing extras:
+
+```sh
+pip install 'databricks-mason[tracing]'
+```
+
+## Authentication
+
+Mason uses [Databricks authentication](https://docs.databricks.com/aws/en/dev-tools/cli/authentication).
+If you do not already have credentials, authenticate a named profile first. You can
+then ask Mason to validate and remember that profile:
+
+```sh
+databricks auth login --profile <profile>
+mason login --profile <profile>
+mason sessions stores list
+```
+
+`mason login` does not create credentials; it stores the selected profile in
+`~/.mason/config.json`. `mason logout` forgets that selection without revoking the
+underlying credentials. If Databricks SDK default authentication is already configured,
+you can skip `mason login`. You can also pass `--profile/-p` for an individual command.
+Use `--output json` for scripting.
+
+## Python SDK
+
+The same memory and session APIs are available programmatically through
+`MasonClient`, which authenticates exactly like the CLI (a `.databrickscfg` profile
+or the SDK's default resolution):
+
+```python
+from databricks_mason import MasonClient
+
+client = MasonClient(profile="my-workspace")  # or MasonClient() for default auth
+
+store = client.create_memory_store("my-store")
+print(store.name, store.display_name)  # typed attribute access
+
+client.create_memory_entry("my-store", actor_id="alice", path="/notes/1.md", content="hi")
+for entry in client.list_memory_entries("my-store", actor_id="alice").entries:
+    print(entry.path, entry.content)
+```
+
+Each method maps to one `/api/agents/v1` operation. Responses come back as typed
+models (`MemoryStore`, `Session`, `SessionItemList`, ...) that expose attribute
+accessors (`store.name`) while remaining plain dicts underneath — so `store["name"]`,
+`json.dumps(store)`, and any new server-side fields keep working. API errors raise
+`databricks_mason.AgentCliError`. Deployment, sandbox, and tracing remain CLI-only.
+
+## Commands
+
+```text
+mason [-p <profile>] [-o text|json]
+  login        [--profile P]
+  logout
+  init         [--framework openai|langgraph] [--disable-chat-app]
+               [--profile P] [--repo URL] [--ref REF] [directory]
+  dev          [--source PATH] [--prepare-environment] [--app-port PORT]
+               [--memory/-m N] [--session/-s N]
+               [--with-traces C.S] [--no-create-stores]
+  memory
+    stores     create | list | get | update | delete
+    entries    create | get | list | search | update | delete
+  sessions     create | list | get | update | delete | fork
+    stores     create | list | get | update | delete
+    items      list | append | pop | clear
+  tracing
+    setup      --catalog C --schema S [--experiment E]
+    list | get | instrument
+  mcp
+    list             [--schema CATALOG.SCHEMA]
+  tools
+    add sandbox      --scope SCOPE [--scope SCOPE ...] [--source PATH]
+    add mcp          SERVICE [--name NAME] [--source PATH]
+    add uc-function  FUNCTION [--name NAME] [--source PATH]
+    add python       NAME [--source PATH]
+    list             [--source PATH]
+  deploy       <name> --source PATH [--memory/-m N]
+               [--session/-s N] [--actor-id ID]
+               [--with-traces C.S] [--no-create-stores]
+  deployments  list | get | logs | start | stop | delete
+```
+
+## Command help
+
+Use the conventional help flag at any command level. Every command's help includes runnable
+examples:
+
+```sh
+mason --help
+mason deploy --help
+mason sessions items append --help
+```
+
+For the shortest path from a blank directory to a running and deployed agent:
+
+```sh
+mason login --profile my-workspace
+mason init my-agent
+cd my-agent
+mason dev
+mason deploy my-agent
+```
+
+## Agent tools
+
+`mason init` writes portable tool intent to `agent.toml` and template provenance to
+`.mason/project.toml`. The manifest runtime is currently implemented only by the in-repository
+`agent-langgraph` template; `mason tools add` fails explicitly for other frameworks until they
+provide an adapter at the same runtime seam.
+
+Remote tools update only `agent.toml`; they do not generate framework source. The LangGraph runtime
+loads the manifest and materializes its native MCP tools when the agent runs, so a direct manifest
+edit and a CLI edit have the same behavior:
+
+```sh
+mason tools add sandbox --scope table:samples.nyctaxi.trips
+mason tools add mcp system.ai.web_search
+mason tools add uc-function catalog.schema.lookup_ticket
+mason tools add python lookup-ticket
+mason tools list
+```
+
+Discover the MCP Services available to your user before adding one. By default Mason lists the
+Databricks-managed services in `system.ai`; pass `--schema catalog.schema` for another Unity Catalog
+schema. Text output includes a copyable add command, while `--output json` returns normalized service
+records for scripts:
+
+```sh
+mason mcp list
+mason mcp list --schema main.tools
+```
+
+The Python command additionally creates user-owned `agent/tools/<name>.py` and
+`tests/tools/test_<name>.py` files using the LangGraph-native `@tool` decorator. `mason dev` and
+`mason deploy` preserve `agent.toml`; they do not generate or patch agent source.
+
+Sandbox scopes default to read-only access. Repeat `--scope` to allow more than one resource, use
+`volume:` or `workspace:` for those resource types, and use `--permission read_write` only when the
+agent needs writes. Every sandbox call carries this fixed downscope in MCP `_meta`, outside the tool
+arguments controlled by the model.
+
+## Initialize the chat app demo
+
+The chat app is a LangGraph-specific init overlay, not a command that mutates an existing project.
+It is included by default for `--framework langgraph`; pass `--disable-chat-app` to scaffold the
+API-only backend instead.
+
+```sh
+mason init --framework langgraph \
+  --profile <profile> \
+  ./my-agent
+cd ./my-agent
+uv run start-server
+```
+
+The chat app includes synchronous, SSE streaming, background polling, Session Store, Memory Store,
+and HITL resume UI. The framework-specific overlay adds `ui/`, `runtime/ui.py`, the UI-enabled
+`runtime/main.py`, and UI tests.
+
+For the full deployed demo, connect both managed stores:
+
+```sh
+mason --profile <profile> deploy mason-agent-demo --source . \
+  --session mason-demo-sessions \
+  --memory mason-demo-memory \
+  --actor-id alice
+```
+
+(Missing stores are created automatically; pass `--no-create-stores` to require they already exist.)
+
+The Databricks Apps `__Host-databricks-app-router` cookie is both the sticky routing key and the
+application session id. The browser sends it automatically; API clients must reuse it as a cookie.
+Request bodies never carry `session_id`. A localhost-only `mason-local-session` cookie provides the
+same behavior outside Databricks Apps. TODO: move to `X-Routing-Key` when Apps supports it.
+
+The generated `README.md` documents every request the client makes: config discovery, sync and SSE
+invocations, background submission and polling, session transcript loading, HITL resume, and memory
+entry operations. Capability colors are automatic from `/api/demo/config`; only the
+sync/streaming/background transport selector is manual.

databricks_mason-0.1.2.dev0/README.md

@@ -0,0 +1,202 @@
+# `databricks-mason`
+
+Mason is an experimental CLI for Databricks custom agent preview APIs and
+deployments. It manages memory, sessions, tracing, and deployments from one
+authenticated command.
+
+> The underlying APIs are in preview and may need workspace enablement.
+
+## Installation
+
+From PyPI:
+
+```sh
+pip install databricks-mason
+```
+
+From source:
+
+```sh
+pip install 'git+https://github.com/databricks/databricks-ai-bridge.git#subdirectory=integrations/mason'
+```
+
+For tracing commands, install Mason with tracing extras:
+
+```sh
+pip install 'databricks-mason[tracing]'
+```
+
+## Authentication
+
+Mason uses [Databricks authentication](https://docs.databricks.com/aws/en/dev-tools/cli/authentication).
+If you do not already have credentials, authenticate a named profile first. You can
+then ask Mason to validate and remember that profile:
+
+```sh
+databricks auth login --profile <profile>
+mason login --profile <profile>
+mason sessions stores list
+```
+
+`mason login` does not create credentials; it stores the selected profile in
+`~/.mason/config.json`. `mason logout` forgets that selection without revoking the
+underlying credentials. If Databricks SDK default authentication is already configured,
+you can skip `mason login`. You can also pass `--profile/-p` for an individual command.
+Use `--output json` for scripting.
+
+## Python SDK
+
+The same memory and session APIs are available programmatically through
+`MasonClient`, which authenticates exactly like the CLI (a `.databrickscfg` profile
+or the SDK's default resolution):
+
+```python
+from databricks_mason import MasonClient
+
+client = MasonClient(profile="my-workspace")  # or MasonClient() for default auth
+
+store = client.create_memory_store("my-store")
+print(store.name, store.display_name)  # typed attribute access
+
+client.create_memory_entry("my-store", actor_id="alice", path="/notes/1.md", content="hi")
+for entry in client.list_memory_entries("my-store", actor_id="alice").entries:
+    print(entry.path, entry.content)
+```
+
+Each method maps to one `/api/agents/v1` operation. Responses come back as typed
+models (`MemoryStore`, `Session`, `SessionItemList`, ...) that expose attribute
+accessors (`store.name`) while remaining plain dicts underneath — so `store["name"]`,
+`json.dumps(store)`, and any new server-side fields keep working. API errors raise
+`databricks_mason.AgentCliError`. Deployment, sandbox, and tracing remain CLI-only.
+
+## Commands
+
+```text
+mason [-p <profile>] [-o text|json]
+  login        [--profile P]
+  logout
+  init         [--framework openai|langgraph] [--disable-chat-app]
+               [--profile P] [--repo URL] [--ref REF] [directory]
+  dev          [--source PATH] [--prepare-environment] [--app-port PORT]
+               [--memory/-m N] [--session/-s N]
+               [--with-traces C.S] [--no-create-stores]
+  memory
+    stores     create | list | get | update | delete
+    entries    create | get | list | search | update | delete
+  sessions     create | list | get | update | delete | fork
+    stores     create | list | get | update | delete
+    items      list | append | pop | clear
+  tracing
+    setup      --catalog C --schema S [--experiment E]
+    list | get | instrument
+  mcp
+    list             [--schema CATALOG.SCHEMA]
+  tools
+    add sandbox      --scope SCOPE [--scope SCOPE ...] [--source PATH]
+    add mcp          SERVICE [--name NAME] [--source PATH]
+    add uc-function  FUNCTION [--name NAME] [--source PATH]
+    add python       NAME [--source PATH]
+    list             [--source PATH]
+  deploy       <name> --source PATH [--memory/-m N]
+               [--session/-s N] [--actor-id ID]
+               [--with-traces C.S] [--no-create-stores]
+  deployments  list | get | logs | start | stop | delete
+```
+
+## Command help
+
+Use the conventional help flag at any command level. Every command's help includes runnable
+examples:
+
+```sh
+mason --help
+mason deploy --help
+mason sessions items append --help
+```
+
+For the shortest path from a blank directory to a running and deployed agent:
+
+```sh
+mason login --profile my-workspace
+mason init my-agent
+cd my-agent
+mason dev
+mason deploy my-agent
+```
+
+## Agent tools
+
+`mason init` writes portable tool intent to `agent.toml` and template provenance to
+`.mason/project.toml`. The manifest runtime is currently implemented only by the in-repository
+`agent-langgraph` template; `mason tools add` fails explicitly for other frameworks until they
+provide an adapter at the same runtime seam.
+
+Remote tools update only `agent.toml`; they do not generate framework source. The LangGraph runtime
+loads the manifest and materializes its native MCP tools when the agent runs, so a direct manifest
+edit and a CLI edit have the same behavior:
+
+```sh
+mason tools add sandbox --scope table:samples.nyctaxi.trips
+mason tools add mcp system.ai.web_search
+mason tools add uc-function catalog.schema.lookup_ticket
+mason tools add python lookup-ticket
+mason tools list
+```
+
+Discover the MCP Services available to your user before adding one. By default Mason lists the
+Databricks-managed services in `system.ai`; pass `--schema catalog.schema` for another Unity Catalog
+schema. Text output includes a copyable add command, while `--output json` returns normalized service
+records for scripts:
+
+```sh
+mason mcp list
+mason mcp list --schema main.tools
+```
+
+The Python command additionally creates user-owned `agent/tools/<name>.py` and
+`tests/tools/test_<name>.py` files using the LangGraph-native `@tool` decorator. `mason dev` and
+`mason deploy` preserve `agent.toml`; they do not generate or patch agent source.
+
+Sandbox scopes default to read-only access. Repeat `--scope` to allow more than one resource, use
+`volume:` or `workspace:` for those resource types, and use `--permission read_write` only when the
+agent needs writes. Every sandbox call carries this fixed downscope in MCP `_meta`, outside the tool
+arguments controlled by the model.
+
+## Initialize the chat app demo
+
+The chat app is a LangGraph-specific init overlay, not a command that mutates an existing project.
+It is included by default for `--framework langgraph`; pass `--disable-chat-app` to scaffold the
+API-only backend instead.
+
+```sh
+mason init --framework langgraph \
+  --profile <profile> \
+  ./my-agent
+cd ./my-agent
+uv run start-server
+```
+
+The chat app includes synchronous, SSE streaming, background polling, Session Store, Memory Store,
+and HITL resume UI. The framework-specific overlay adds `ui/`, `runtime/ui.py`, the UI-enabled
+`runtime/main.py`, and UI tests.
+
+For the full deployed demo, connect both managed stores:
+
+```sh
+mason --profile <profile> deploy mason-agent-demo --source . \
+  --session mason-demo-sessions \
+  --memory mason-demo-memory \
+  --actor-id alice
+```
+
+(Missing stores are created automatically; pass `--no-create-stores` to require they already exist.)
+
+The Databricks Apps `__Host-databricks-app-router` cookie is both the sticky routing key and the
+application session id. The browser sends it automatically; API clients must reuse it as a cookie.
+Request bodies never carry `session_id`. A localhost-only `mason-local-session` cookie provides the
+same behavior outside Databricks Apps. TODO: move to `X-Routing-Key` when Apps supports it.
+
+The generated `README.md` documents every request the client makes: config discovery, sync and SSE
+invocations, background submission and polling, session transcript loading, HITL resume, and memory
+entry operations. Capability colors are automatic from `/api/demo/config`; only the
+sync/streaming/background transport selector is manual.

databricks_mason-0.1.2.dev0/pyproject.toml

@@ -0,0 +1,93 @@
+[project]
+name = "databricks-mason"
+version = "0.1.2.dev0"
+description = "Databricks integration for Mason"
+authors = [
+    { name="Databricks", email="agent-feedback@databricks.com" },
+]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.1",
+    "databricks-sdk>=0.49",
+    "psycopg[binary]>=3.1",
+    "PyYAML>=6.0",
+    "rich>=13.7",
+    "tomli>=2.0",
+    "tomlkit>=0.13",
+]
+
+[project.optional-dependencies]
+tracing = [
+    "mlflow[databricks]>=3.9.0",
+]
+# The agent-side runtime helpers a deployed agent imports. Kept as extras so a plain
+# `pip install databricks-mason` (the CLI) stays light; each template depends on the extra for its
+# framework. `runtime` = the LangGraph adapter (databricks_mason.langgraph); `runtime-openai` = the
+# OpenAI Agents SDK adapter (databricks_mason.openai). Both carry the shared framework-neutral stack
+# (databricks_mason.runtime); the framework SDKs differ, so an agent installs only the one it uses.
+runtime = [
+    "databricks-langchain>=0.17.0",
+    "langgraph>=1.1.0",
+    "langchain>=1.0.0",
+    "langchain-mcp-adapters>=0.2.1",
+    "fastapi>=0.129.0",
+    "mlflow>=3.10.1",
+    "uuid-utils>=0.10.0",
+    "opentelemetry-exporter-otlp-proto-grpc>=1.25.0",
+    "databricks-agents>=1.9.3",
+]
+runtime-openai = [
+    "openai-agents>=0.4.1",
+    "databricks-openai>=0.13.0",
+    "fastapi>=0.129.0",
+    "mlflow>=3.10.1",
+    "uuid-utils>=0.10.0",
+    "opentelemetry-exporter-otlp-proto-grpc>=1.25.0",
+    "databricks-agents>=1.9.3",
+]
+
+[project.scripts]
+mason = "databricks_mason.cli:main"
+
+[dependency-groups]
+dev = [
+    "ruff==0.14.10",
+    "ty==0.0.23",
+    { include-group = "tests" },
+]
+tests = [
+    "pytest==9.0.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+include = [
+    "NOTICE",
+    "src/databricks_mason/*",
+    "src/databricks_mason/py.typed",
+    "src/databricks_mason/templates/**",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/databricks_mason"]
+
+[tool.ruff]
+include = ["pyproject.toml", "src/**/*.py", "tests/**/*.py"]
+extend = "../../pyproject.toml"
+
+[tool.pytest.ini_options]
+testpaths = ["tests/unit_tests"]
+
+[tool.ty.environment]
+root = ["./src", "./tests"]
+
+[tool.ty.src]
+include = ["./src", "./tests"]
+# The files under templates/ are code-as-data — scaffolding snippets written into a generated agent
+# project, not importable package modules. They import scaffold-relative paths (agent.mason.*,
+# agent.mcps) that never resolve in the package, so type-checking them here is meaningless.
+exclude = ["./src/databricks_mason/templates"]

databricks_mason-0.1.2.dev0/src/databricks_mason/__init__.py

@@ -0,0 +1,89 @@
+"""Databricks integration for Mason.
+
+Mason ships a `mason` CLI and this Python SDK over the same agents/v1 preview APIs.
+Construct a `MasonClient` and call one method per API operation:
+
+    from databricks_mason import MasonClient
+
+    client = MasonClient(profile="my-workspace")
+    client.create_memory_store("my-store")
+    for entry in client.list_memory_entries("my-store", actor_id="alice").get("entries", []):
+        ...
+
+Auth resolves through the Databricks SDK: pass a `.databrickscfg` profile or rely on
+its default resolution. API errors surface as `AgentCliError`.
+
+The framework-neutral runtime helpers (``configure_tracing``, ``tag_session``, ``workspace_client``,
+``workspace_headers``) are also re-exported here for convenience — they live in
+:mod:`databricks_mason.runtime` and are resolved lazily (PEP 562) so a plain CLI ``import
+databricks_mason`` does not pull in the tracing module's ``mlflow`` dependency.
+"""
+
+from typing import TYPE_CHECKING
+
+from databricks_mason.client import MasonClient, memory_entry_path, memory_store_path
+from databricks_mason.errors import AgentCliError
+from databricks_mason.models import (
+    MemoryEntry,
+    MemoryEntryList,
+    MemorySearchHit,
+    MemorySearchResult,
+    MemoryStore,
+    MemoryStoreList,
+    PoppedSessionItem,
+    Session,
+    SessionItem,
+    SessionItemList,
+    SessionList,
+    SessionStore,
+    SessionStoreList,
+    StorageBackend,
+)
+
+if TYPE_CHECKING:
+    from databricks_mason.runtime import (
+        configure_tracing,
+        tag_session,
+        workspace_client,
+        workspace_headers,
+    )
+
+__all__ = [
+    "MasonClient",
+    "AgentCliError",
+    "memory_store_path",
+    "memory_entry_path",
+    "MemoryStore",
+    "MemoryStoreList",
+    "MemoryEntry",
+    "MemoryEntryList",
+    "MemorySearchResult",
+    "MemorySearchHit",
+    "StorageBackend",
+    "SessionStore",
+    "SessionStoreList",
+    "Session",
+    "SessionList",
+    "SessionItem",
+    "SessionItemList",
+    "PoppedSessionItem",
+    # Framework-neutral runtime helpers (lazily re-exported from databricks_mason.runtime).
+    "configure_tracing",
+    "tag_session",
+    "workspace_client",
+    "workspace_headers",
+]
+
+# Neutral runtime helpers, re-exported lazily so the light CLI import path stays free of the agent
+# stack (mlflow, etc.). Everything else above is light and imported eagerly.
+_RUNTIME_REEXPORTS = frozenset(
+    {"configure_tracing", "tag_session", "workspace_client", "workspace_headers"}
+)
+
+
+def __getattr__(name: str) -> object:
+    if name in _RUNTIME_REEXPORTS:
+        import importlib
+
+        return getattr(importlib.import_module("databricks_mason.runtime"), name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")