Metadata-Version: 2.4
Name: fabric-data-agent-sdk
Version: 0.1.33a0
Summary: SDK for the Fabric Data Agent Library
Author: Microsoft Corporation
License-Expression: MIT
Project-URL: Repository, https://msdata.visualstudio.com/DefaultCollection/A365/_git/SynapseML-Agent-SDK
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3 :: Only
Requires-Python: <3.14,>=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: azure-core<2,>=1.23.0
Requires-Dist: semantic-link-sempy>=0.14.1
Requires-Dist: fabric-analytics-sdk<1,>=0.0.3.post10
Requires-Dist: fabric-analytics-notebook-plugin<1,>=0.0.3
Requires-Dist: openai<3,>=1.101.0
Requires-Dist: httpx==0.27.2
Requires-Dist: semantic-link-labs<0.18,>=0.15.2
Requires-Dist: azure-kusto-data>=4.5.0
Requires-Dist: azure-identity==1.17.1
Requires-Dist: azure-storage-file-datalake<13,>=12.17
Requires-Dist: deltalake<2,>=0.25
Requires-Dist: jinja2<4,>=3.1
Requires-Dist: markdown2==2.5.3
Requires-Dist: tabulate>=0.9.0
Dynamic: license-file

The Fabric Data Agent SDK supports programmatic access for [Fabric Data Agent](https://learn.microsoft.com/en-us/fabric/data-science/concept-ai-skill) 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.

```python
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](https://learn.microsoft.com/en-us/fabric/enterprise/licenses). Or sign up for a free [Microsoft Fabric (Preview) trial](https://learn.microsoft.com/en-us/fabric/get-started/fabric-trial).
* Sign in to [Microsoft Fabric](https://fabric.microsoft.com/).
* Create a [Fabric Python notebook](https://learn.microsoft.com/en-us/fabric/data-engineering/using-python-experience-on-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:

  ```python
  %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:

```python
%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:

```python
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:

```python
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:

```python
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`:

```python
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:

```python
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:

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

In an IDE, pass any local path:

```python
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:

```python
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"`:

```python
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.

```python
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.

| Output format | Destination within the Lakehouse |
| --- | --- |
| `delta_table`, non-schema Lakehouse | `Tables/evaluation_results` |
| `delta_table`, schema-enabled Lakehouse | `Tables/<existing-schema>/evaluation_results` |
| `delta`, `json`, `csv`, `parquet` | `Files/evaluations/results` (nested directories allowed) |

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](https://learn.microsoft.com/en-us/fabric/onelake/onelake-access-api#uri-syntax).
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.

```python
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:

```python
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.

```python
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
