The Fabric Data Agent SDK supports programmatic access for Fabric Data Agent artifacts.

This package is released as a preview and has been tested with Microsoft Fabric Python notebooks.

Getting started

Headless inference

FabricOpenAIResponses and FabricOpenAI accept an explicit Azure TokenCredential and workspace for ordinary Python processes. The credential must already be authorized for the target workspace, agent and data sources. The SDK does not grant permissions, sign in interactively, or fall back to a different identity.

This requires a release containing the headless changes or a candidate wheel installed with its dependencies. The example assumes Azure CLI is already signed in to an authorized identity.

AzureCliCredential is convenient for a developer smoke check, not for throughput or benchmark-latency measurements: Azure Identity's CLI credential does not cache tokens, so every get_token call launches an az process, including retries and concurrent requests. For unattended/high-throughput use, inject an authorized credential provider with thread-safe token caching and refresh (as the Quality runner does). This SDK intentionally does not add a second token cache.

from azure.identity import AzureCliCredential
from fabric.analytics.environment.base.context import InternalContext
from fabric.dataagent.client import FabricOpenAIResponses

with FabricOpenAIResponses(
    artifact_name="<data-agent-id>",
    workspace_name="<workspace-id>",
    credential=AzureCliCredential(),
    context=InternalContext(rollout_stage="prod"),
) as client:
    response = client.responses.create(input="What is total revenue?")
    print(response.output_text)

Use the appropriate authorized rollout stage (for example daily, dxt or msit) in internal environments. The default is prod. Context and credential are captured per client: changing an ambient notebook/context override later does not change that client's identity, environment or token audience. The SDK requests canonical OAuth scopes from the supplied credential for each request, including retries, files and diagnostics; token caching/refresh belongs to the credential. Passing context without credential is rejected. A caller-owned credential is not closed by the SDK. Global Analytics context/credential overrides alone do not select this mode: outside-notebook integrations must pass credential to the inference constructor. The existing ai_skill_stage="sandbox" default is unchanged.

Headless metadata resolution uses Fabric REST rather than SemPy's XMLA lookup. IDs avoid list permissions; names must resolve uniquely across all pages and both supported types (DataAgent and Warehouse). Use an ID for names shared across types. UUID-shaped identifiers are treated strictly as IDs: a missing ID never falls back to a different artifact whose display name happens to be that UUID. The context is a value-only InternalContext, not a provider-backed FabricContext. API hosts are selected from a closed rollout map, independently of ambient notebook/context overrides. Cluster and workload authorities must match both their endpoint role and the selected cloud; commercial, PPE and government tokens cannot cross those cloud boundaries. cst is rejected because it has no defined API host. Arbitrary API-host overrides are not supported. Region routing comes from the resolved target capacity, not the context's optional region hint.

Discovery reads the selected workspace/capacity and uses the Fabric cluster/MWC routing endpoints for that target, not an inherited notebook workload host. Discovery still requires an identity authorized for those service operations; an arbitrary service principal or managed identity is not guaranteed to work. No notebook, Spark session, .NET initialization or synapseml-utils is required by this inference path. SemPy and the notebook plugin remain installed for existing management, datasource and evaluation functionality.

Authenticated headless requests require HTTPS on recognized Fabric service domains. Discovery results and pagination authorities are validated before tokens are sent, and redirects are not followed, even with a caller-provided HTTP client. Arbitrary workload-host overrides and HTTP/local test hosts are not supported in this path. A supplied http_client carries discovery, inference, files and diagnostics; its transport is trusted caller code and the usual OpenAI client close/ownership contract still applies. Ownership of a supplied HTTP client transfers only after successful SDK-client construction. A failed constructor leaves that caller-supplied transport open.

Metadata, discovery, diagnostics and raw thread-helper operations use 30-second connect/read/write/pool timeouts, not a total wall-clock deadline, and do not add automatic retries. OpenAI inference and file operations retain their OpenAI retry/timeout options. In the headless REST path, HTTP failures raise httpx.HTTPStatusError, transport failures raise httpx.RequestError, redirects raise RuntimeError, and invalid metadata/unexpected successful statuses raise ValueError. These are distinct from the notebook REST path's FabricHTTPException; malformed URLs can also raise httpx.InvalidURL before any credentials or network I/O. Always close clients or use with to release owned HTTP connections. Without credential, the existing Fabric Python/Spark notebook behavior and runtime providers remain unchanged. Headless inference does not make evaluate_data_agent() or all datasource/management helpers headless, and it does not change grading, storage or publication behavior.

Workspace-private-link (is_wspl_enabled=True) contexts are explicitly rejected by the headless path until target-specific routing is qualified. They never fall back to an ambient workspace or interactive prompt. Client-level Authorization headers and HTTP client auth must not compete with the explicit credential; conflicting configuration fails before authentication or discovery.

Fabric notebook prerequisites

• A Microsoft Fabric subscription. Or sign up for a free Microsoft Fabric (Preview) trial.
• Sign in to Microsoft Fabric.
• Create a Fabric Python notebook to use this package. A PySpark kernel is not required; existing Spark notebooks remain supported. Note that semantic link is supported only within Microsoft Fabric.

Install the fabric-data-agent-sdk package

To install the most recent version fabric-data-agent-sdk in your Fabric Python notebook kernel by executing this code in a notebook cell:

%pip install -U fabric-data-agent-sdk

Custom wheels and older Fabric runtimes

The SDK requires semantic-link-sempy>=0.14.1. A Fabric runtime's preinstalled SemPy version may be older. Install custom SDK wheels with dependency resolution enabled, replacing the placeholder below with your wheel's location:

%pip install --upgrade "<path-to-sdk-wheel.whl>"
%pip check

Do not add --no-deps unless the environment already satisfies all SDK dependency requirements. That flag skips dependency installation, including the required SemPy upgrade. If dependency-free wheel installation is necessary in a preconfigured environment, ensure semantic-link-sempy>=0.14.1 is installed and run %pip check afterward to identify missing or incompatible dependencies.

After changing packages, restart the notebook's Python session before importing the SDK. An already imported SemPy module can retain the old function signature even when package metadata reports the upgraded version.

If item-name resolution reports an incompatible list_items signature, collect the installed versions and the loaded module information:

import inspect
from importlib.metadata import version
import sempy.fabric as fabric

print("SDK:", version("fabric-data-agent-sdk"))
print("SemPy:", version("semantic-link-sempy"))
print("Loaded module:", fabric.__file__)
print("list_items:", inspect.signature(fabric.list_items))

Upgrade the SDK with dependencies enabled, or explicitly install semantic-link-sempy>=0.14.1, then restart Python. The diagnostic does not add support for older SemPy versions or catch errors raised inside a compatible list_items implementation. The same signature check applies to Graph and Ontology item lookups. Passing a Data Agent UUID to FabricDataAgentManagement can avoid listing when the direct item lookup succeeds, but is not a substitute for a supported environment: a lookup that falls back to listing still requires a compatible SemPy signature.

Key concepts

Fabric Data Agent SDK has two main entry points:

• Data plane using OpenAI SDK for conversational interaction with an existing Data Agent artifact.
• Management plane to create, update and delete Data Agent artifacts.

OpenAI Responses API

Use FabricOpenAIResponses to interact with Data Agents through the Responses API:

from fabric.dataagent.client import FabricOpenAIResponses

client = FabricOpenAIResponses(artifact_name="my-agent")
conversation = client.conversations.create()

stream = client.responses.stream(
    input="What is total revenue?",
    conversation=conversation.id,
)
for event in stream:
    pass  # process response.* events as they arrive
response = stream.get_final_response()

print(response.output_text)

To chain follow-up calls without creating a conversation, use OpenAI's previous_response_id pattern:

first_response = client.responses.create(input="What is total revenue?")
follow_up_response = client.responses.create(
    input="Which month had the most revenue?",
    previous_response_id=first_response.id,
)

FabricOpenAIResponses sends gpt-5.1 by default when model is omitted. Pass model="..." to responses.create() or responses.stream() to override it. Non-streaming responses.create() and responses.retrieve() calls always return OpenAI Response objects, including when Fabric sends the underlying payload as a server-sent event stream.

Conversation diagnostics

Diagnostics are available for Responses API conversations through FabricOpenAIResponses.diagnostics:

payload = client.diagnostics.get(
    conversation.id,
    response_id=response.id,  # optional
    chat_scenario="fabric-notebook",  # optional
)

Export writes readable UTF-8 JSON and returns a pathlib.Path. With no path, the file is written to the current working directory using a safe filename based on the conversation ID:

path = client.diagnostics.export(conversation.id)

In a Fabric notebook with a default Lakehouse attached, pass a Files path to make the export available in Fabric/OneLake for download or sharing:

path = client.diagnostics.export(
    conversation.id,
    path="/lakehouse/default/Files/data-agent-diagnostics.json",
)

In an IDE, pass any local path:

path = client.diagnostics.export(
    conversation.id,
    path="./data-agent-diagnostics.json",
)

Evaluation uses the Responses API by default; existing calls do not need a client_class argument:

from fabric.dataagent.evaluation import evaluate_data_agent

evaluate_data_agent(
    df,
    data_agent_name="my-agent",
)

Responses evaluations keep the same output tables and evaluation ID return value. The thread_id column contains the conversation ID for compatibility with existing notebooks and tables. The thread_url and evaluation_thread_url fields link to the answer and judge responses respectively when response IDs are available. Failures without a deep link remain visible by conversation or evaluation-row ID. Unsuccessful API responses have an unclear evaluation judgement rather than being counted as answer mismatches. JSON file annotations support both tabular columns/rows data and other valid JSON, with bounded text previews for non-tabular content. If local answer processing fails, the row remains failed/unclear while retaining any received response ID, deep link, and tool telemetry.

Evaluation storage

Evaluation results are written to Delta tables by default (output_format="delta_table"). To write the result and steps datasets under the default Lakehouse Files area instead, set output_format to "delta", "json", "csv", or "parquet":

evaluate_data_agent(
    df,
    data_agent_name="my-agent",
    table_name="my-evaluation-parquet",
    output_format="parquet",
)

Without output_path, attach a default Lakehouse before evaluating. This example appends results to Files/my-evaluation-parquet and steps to Files/my-evaluation-parquet_steps. Each location is a dataset directory, not a single file. JSON uses newline-delimited records; CSV files include a header row. Both preserve microsecond precision in evaluation timestamps. Parquet uses microsecond timestamps for compatibility with Spark.

Without output_path, file-output table_name is a non-empty directory name, not a path: ".", "..", and names containing / or \ are rejected. Files datasets are not registered as Lakehouse tables. Read them directly with a reader for the selected format; existing evaluation report helpers only read Delta tables. evaluate_data_agent() still returns an evaluation ID, not an output path.

All file formats share the same Files/<table_name> and Files/<table_name>_steps locations. Use a different table_name for each file format: changing output_format does not convert existing files, and mixing formats in one directory can make it unreadable by a single-format reader.

All formats append to existing outputs. Write failures raise RuntimeError; results and steps are written separately, so a failure can leave partial output.

Spark Delta appends use the existing destination schema before converting the current batch, including when optional columns are all null. Path-backed outputs read this schema directly from the Delta path, independently of catalog discovery. Existing timestamp types are preserved; new outputs infer a schema and use timestamp_ntz for run_timestamp. Only specific path/Delta-table absence errors permit inference for a new destination. Permission, protocol, and metadata errors are surfaced instead of treating an unreadable table as new.

Explicit output destinations

output_path is the full results dataset destination, not its parent folder. It overrides table_name. Absolute OneLake abfs:// and abfss:// URIs do not require an attached or mounted Lakehouse. The caller still needs access to the target Lakehouse. Relative paths starting with Tables/ or Files/ resolve against the attached default Lakehouse, not the notebook's working directory.

from fabric.dataagent.evaluation import evaluate_data_agent, get_evaluation_summary

output_path = (
    "abfss://<workspace-id>@onelake.dfs.fabric.microsoft.com/"
    "<lakehouse-id>/Tables/dbo/evaluation_results"
)
evaluation_id = evaluate_data_agent(
    evaluation_input,
    data_agent_name=DATA_AGENT_ID,
    output_path=output_path,
    output_format="delta_table",
)
summary = get_evaluation_summary(output_path=output_path)

The steps destination in this example is Tables/dbo/evaluation_results_steps. A trailing slash is accepted and removed before appending _steps to the final path segment.

Explicit table and schema names use letters, numbers, and underscores. A named OneLake URI uses <workspace-name>@.../<lakehouse-name>.Lakehouse/...; GUID-based URIs use both workspace and Lakehouse IDs. Non-OneLake storage URIs, local filesystem paths, traversal segments, and URIs containing credentials, queries, or fragments are not supported. File formats remain datasets under Files, not registered Lakehouse tables. delta_table writes Delta data to the Lakehouse's Tables layout for Fabric table discovery; it does not register an arbitrary external storage location as a table.

Workspace names containing spaces are not supported in ABFS authorities, even when the spaces are percent-encoded (for example, My%20Workspace@...). Use both the workspace GUID and Lakehouse GUID instead, as recommended by the OneLake URI documentation. This restriction does not apply to spaces in Lakehouse names or Files paths.

For explicit file paths, raw and URI-encoded names identify the same directory in Python and Spark. For example, Files/eval runs and Files/eval%20runs both select the eval runs directory, not a directory literally named eval%20runs. This also applies to named Lakehouses and names containing =, +, parentheses, or Unicode characters.

Path syntax and table-layout checks run before agent evaluation. Table paths are checked against the target Lakehouse's Fabric metadata; named schemas must already exist. Metadata and schema-access failures are surfaced, never treated as a reason to write elsewhere. A missing default Lakehouse fails early for relative paths and default destinations. Writes can still fail later due to permissions, incompatible existing data, or concurrent changes.

All three Delta-table report helpers (get_evaluation_details, get_evaluation_summary, and get_evaluation_summary_per_question) accept the same output_path. Explicit-path read failures raise; they do not fall back to the attached Lakehouse. File datasets still require their format-specific reader.

When output_path is omitted, existing working destinations are retained: Spark uses the eval_result schema on schema-enabled Lakehouses; non-schema Lakehouses use root Tables; file outputs use Files/<table_name>. Python now uses the Lakehouse's default schema (normally dbo) for schema-enabled tables instead of writing to the invalid root-Tables location. Use an explicit path when sharing outputs between Python and Spark. On non-schema Lakehouses, legacy path-backed table_name values containing hyphens, dots, or Unicode remain supported for writes and reports; the name must still be a single non-empty directory segment, not . or ... Schema-enabled default tables retain the stricter letters/numbers/underscores rule.

Ontology query payloads

OntologySource.execute() and its connection's query() accept an ontology request dictionary or a valid JSON string encoding that object. Both forms send the same JSON object to the service; dictionary inputs are not modified.

import json
from fabric.dataagent.datasources.ontology import OntologySource

source = OntologySource("my-ontology", "my-workspace")
payload = {
    "entitySelector": {
        "query": "MATCH (p:Person) RETURN p",
        "queryType": "GQL",
    }
}
result = source.execute(payload)
with source.connect() as connection:
    result = connection.query(json.dumps(payload))

For ground-truth query strings, use json.dumps(payload), not str(payload) or single-quoted Python dictionary syntax. Malformed JSON (including NaN and Infinity) and JSON top-level arrays, scalars, or null raise ValueError. Inputs other than strings or dictionaries raise TypeError. These checks run before MWC token acquisition or the query HTTP request. Object schema validation remains the service's responsibility; service failures still raise FabricHTTPException.

Management plane API

Use create_data_agent and delete_data_agent to create and delete Data Agent items. Use FabricDataAgentManagement for management-plane APIs. Existing workload-host management methods such as add_datasource() remain available for compatibility and keep their original return types, but emit deprecation warnings with the public API method to use instead. Public API methods use explicit names such as get_settings(), update_settings(), add_staging_datasource(), list_datasources(), delete_staging_datasource(), publish_staging(), and reset_staging().

Consumer feedback

Use FabricDataAgentManagement.list_feedback() to list consumer feedback as a pandas DataFrame:

from fabric.dataagent.client import FabricDataAgentManagement

data_agent = FabricDataAgentManagement(
    data_agent="my-agent",
    workspace=None,
)

feedback = data_agent.list_feedback(
    channels=["M365Copilot"],
    feedback_types=["Frown"],
    search="stale data",
    sort_by="submitted_at",
    ascending=False,
)

assert list(feedback.columns) == [
    "question",
    "response",
    "rating",
    "comment",
    "has_attachments",
    "submitted_at",
    "feedback_id",
]

The DataFrame always uses those seven columns in that order, including for an empty result. question and response come from the OCV AI context. Recognized thumbs-up and thumbs-down feedback subtypes are returned as liked and disliked; unknown or missing ratings are None. feedback_id remains available as the final technical column. A true has_attachments value plus a usable feedback_id identifies attachment candidates; the attachment endpoint still rechecks ownership and current attachment availability.

The supported filters are channels, products, platforms, feedback_types, search, start_date, and end_date. Collection filters use the raw OCV vocabulary, for example channels=["M365Copilot"], products=["Fabric"], platforms=["Web"], and feedback_types=["Frown"]. The only supported sort_by values are the visible columns that the service can sort: submitted_at, comment, rating, and has_attachments. The projected question, response, and feedback_id columns are not sortable. Listing follows opaque continuation cursors automatically; set max_results to stop after a bounded number of records. A repeated or cyclic cursor raises FeedbackPaginationError before the SDK can resend it.

Use download_feedback_attachments() to retrieve the attachment ZIP bundle. Without output_path, it returns ZIP bytes. An explicit file path writes there, while an existing directory generates a sanitized, collision-resistant ZIP filename. Directory mode requires output_path to already be a directory; otherwise the path is treated as an explicit file path. Existing files raise FileExistsError unless overwrite=True.

Microsoft sensitivity labels and protections are not preserved on downloaded attachments. Every download must explicitly acknowledge this by setting allow_download_without_sensitivity_label=True; otherwise the SDK raises SensitivityLabelAcknowledgementRequired before sending any download request or writing a file.

from pathlib import Path

attachment_directory = Path("/lakehouse/default/Files/feedback")
attachment_directory.mkdir(parents=True, exist_ok=True)

zip_bytes = data_agent.download_feedback_attachments(
    "feedback-id",
    allow_download_without_sensitivity_label=True,
)
saved_path = data_agent.download_feedback_attachments(
    "feedback-id",
    output_path=attachment_directory,
    language="fr-CA",
    allow_download_without_sensitivity_label=True,
)

Sensitive content warning: direct identity columns such as OCV userId, email, and tenantId are not included in the management DataFrame. However, question, response, and comment can still contain sensitive content. Listing and attachment download require a delegated user with effective Data Agent Write permission and an agent published to Microsoft 365.

Consumer feedback APIs are a limited preview available only in supported, enabled environments. List results are limited to feedback shared with the agent builder. Attachment downloads verify agent ownership and current attachment availability, but do not separately re-check builder-sharing consent. The optional language selects only the retention README.txt locale; missing, malformed, or overlong tags use en. README-only ZIP bundles for expired attachments are successful downloads. Expected service failures, including unavailable features, authorization or ownership errors, missing attachments, throttling, and service errors, are raised as FabricHTTPException.

Change logs

Unreleased

0.1.33a0

• add limited-preview API support for listing OCV consumer feedback in a stable seven-column management DataFrame, sorting by the visible service-sortable columns, and downloading feedback attachment ZIPs with explicit acknowledgement that Microsoft sensitivity labels and protections are not preserved.
• add opt-in headless inference with explicit per-client credentials, canonical scopes, REST metadata resolution and guarded target-bound workload discovery.
• add explicit OneLake output_path for evaluation results and Delta-table reports, including no-attached-Lakehouse writes and schema-aware table validation.
• surface Delta write failures and stop redirecting failed schema writes to root Tables.
• send Ontology JSON-string queries as objects instead of double-encoded strings, preserve dictionary inputs, and reject invalid input before token acquisition.
• support the Fabric Python notebook kernel without requiring PySpark runtime APIs.
• report actionable SemPy compatibility errors during item-name resolution.
• add output_format to persist evaluation results and steps as Delta, JSON, CSV, or Parquet datasets under Lakehouse Files; Delta tables remain the default.

0.1.32a0

• default evaluate_data_agent() to FabricOpenAIResponses instead of the deprecated Assistants API.
• populate answer and judge deep links for Responses evaluations while retaining the existing output column names.
• preserve failed-row notifications and report rendering when a deep link is unavailable, without emitting empty-target links.
• record conversation-creation request failures as failed rows without discarding completed rows, and leave infrastructure failures unscored.
• close both Responses HTTP clients after each evaluation row.
• support non-tabular JSON file annotations and retain response links and telemetry when local answer processing fails.

0.1.31a0

• add required LLM endpoint classification headers to Assistants and Responses API requests.
• add support for retrieving and exporting Responses API conversation diagnostics.

0.1.30a0

• bugfix - final-response proxy drops mapping-backed status and ID attributes.
• add Python 3.13 support.
• simplify package dependencies to avoid unnecessary installations.
• cap the openai dependency to >=1.101.0,<3 because of incompatibility.

0.1.29a0

• require aiohttp>=3.10 because Fabric runtime dependencies use timeout exception types introduced in that version.

0.1.28a0

• bugfix - normalizes non-streamed responses from Open AI.

0.1.27a0

• add support for the Open AI Responses APIs.

0.1.26a0

• add support for the public Data Agent management-plane APIs via FabricDataAgentManagement.

0.1.25a0

• upgrade the model used for fewshots validation from gpt-4.1 to gpt-5.1.

0.1.24a0

• rename SDK configuration parameter enable_experimental_features to enable_preview_runtime for consistency with the UI "Preview Runtime" label.

0.1.23a0

• add FabricOpenAIResponses for opt-in OpenAI Responses API support while keeping FabricOpenAI for Assistants API callers.
• fix duplicate fewshot bug in add_fewshots() by auto-renaming duplicate questions with [N] suffixes (case-insensitive match).
• update evaluation model and correct prompt typos.

0.1.22a0

• upgrade dependency semantic-link-labs=0.14.3 to allow for python 3.12 support.

0.1.21a0

• fix FabricOpenAI "Missing credentials" error with openai>=2.34.0.

0.1.20a0

• add support for enabling/disabling experimental features.

0.1.19a0

• fix data source type for update configurations and descriptions.

0.1.18a0

• adds data source type and element type support for Mirrored DB and SQL DB
• enable Publishing Data Agent to M365 Copilot Agent Store
• update failed thread message

0.1.17a0

• add conflict detection to few-shot validation with LLM-based semantic analysis
• add file support
• replace thread_url with message_url

0.1.16a0

• add the ontology data source support

0.1.15a0

• fix get datasources error caused by None value
• fix schema selection when adding data sources
• update example notebook

0.1.14a0

• fix thread url for fabcon tenant

0.1.13a0

• add support for granular quality feedback in few-shot validation and improve Dataframe output
• fix invalid data type for delta lake

0.1.12a0

• fix python error in the release pipeline
• add robust few-shot validation utilities to SDK with dual LLM support and DataFrame output
• update parameter type in add-datasource

0.1.11a0

• upgrade OneBranch Azure Linux Build Image: Migrating from 2.0 to 3.0
• remove "AISkill" from artifact name list due to invalid item type error in openai
• make Data Agent and Data Source Creation Idempotent
• add publish description
• refactoring the evaluation apis and add code coverage
• remove AISkill artifact type in data agent api

0.1.10a0

• fix get_evaluation_summary_per_question if no question fails

0.1.9a0

• Use correct workspace context in delete_data_agent function.
• Update notebooks with data source notes
• display failed threads and fix percentage

0.1.8a0

• evaluation API enhancements including parallelizing, number of variations and single thread.
• speed-up add_ground_truth_batch and stabilise Kusto tests
• ground-truth generation for Kusto (KQL) datasources

0.1.7a0

• added Warehouse to list of artifact types.
• added Method for Updating Ground Truth before Evaluation.
• made Publish Info Optional.

0.1.6a0

• update sdk to make compatible with both python and spark.

0.1.5a0

• add PySpark support for the evaluation APIs.
• added pipeline for running unit tests.

0.1.4a0

• switch to public apis for artifact management.

0.1.3a0

• add column/table descriptions for sql data sources.
• allow selection of multiple columns at once in the datasource.
• bug fix to address the run_steps response structure change.

0.1.2a0

• bugfix for fabric_openai artifact type - should support "DataAgent".
• bugfix for data source type ("datawarehouse" should be "warehouse").

0.1.1a0

• bugfix for create_data_agent where type should support "DataAgent".

0.1.0a0

• add upload_fewshots for adding multiple fewshots to DataSource.

0.0.4a0

• add evaluation APIs to the SDK

0.0.3a1

• return fewshot id from add_fewshots
• fix the aiskill stage parameter
• return datasource display name in pretty_print
• return thread object for get_or_create_thread API.

0.0.2a0

• rename module
• support Fabric get_or_create_thread to decouple from UX thread

0.0.1a0

Initial alpha release of the package.

• add: data plane client
• add: management plane client