@azure/ai-projects 2.1.1 → 2.3.0

package/dist/browser/api/agents/operations.js

@@ -1,9 +1,569 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { agentDeserializer, agentVersionDeserializer, agentDefinitionUnionSerializer, agentBlueprintReferenceUnionSerializer, agentEndpointSerializer, agentCardSerializer, apiErrorResponseDeserializer, deleteAgentResponseDeserializer, _agentsPagedResultAgentObjectDeserializer, deleteAgentVersionResponseDeserializer, _agentsPagedResultAgentVersionObjectDeserializer, } from "../../models/models.js";
+import { getBinaryStreamResponse } from "../../static-helpers/serialization/get-binary-stream-response.js";
+import { agentDeserializer, agentVersionDeserializer, agentDefinitionUnionSerializer, agentBlueprintReferenceUnionSerializer, agentEndpointConfigSerializer, agentCardSerializer, apiErrorResponseDeserializer, deleteAgentResponseDeserializer, _agentsPagedResultAgentObjectDeserializer, deleteAgentVersionResponseDeserializer, _agentsPagedResultAgentVersionObjectDeserializer, createAgentVersionFromCodeContentSerializer, versionIndicatorUnionSerializer, agentSessionResourceDeserializer, _agentsPagedResultAgentSessionResourceDeserializer, sessionFileWriteResponseDeserializer, sessionDirectoryListResponseDeserializer, } from "../../models/models.js";
 import { buildPagedAsyncIterator } from "../../static-helpers/pagingHelpers.js";
 import { expandUrlTemplate } from "../../static-helpers/urlTemplate.js";
 import { createRestError, operationOptionsToRequestParameters } from "@azure-rest/core-client";
+import { startSpan } from "../../tracing/tracingClient.js";
+import { setAgentAttributes, setAgentVersionAttributes, setCommonAttributes, } from "../../tracing/attributes.js";
+import { OperationName } from "../../tracing/constants.js";
+export function _deleteSessionFileSend(context, agentName, agentSessionId, path, options = { requestOptions: {} }) {
+    const path_1 = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions/{agent_session_id}/files{?path,recursive,api-version}", {
+        agent_name: agentName,
+        agent_session_id: agentSessionId,
+        path: path,
+        recursive: options?.recursive,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path_1).delete({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _deleteSessionFileDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return;
+}
+/**
+ * Deletes the specified file or directory from the session sandbox.
+ * When `recursive` is false, deleting a non-empty directory returns 409 Conflict.
+ */
+export async function deleteSessionFile(context, agentName, agentSessionId, path, options = { requestOptions: {} }) {
+    const result = await _deleteSessionFileSend(context, agentName, agentSessionId, path, options);
+    return _deleteSessionFileDeserialize(result);
+}
+export function _listSessionFilesSend(context, agentName, agentSessionId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions/{agent_session_id}/files{?path,limit,order,after,before,api-version}", {
+        agent_name: agentName,
+        agent_session_id: agentSessionId,
+        path: options?.path,
+        limit: options?.limit,
+        order: options?.order,
+        after: options?.after,
+        before: options?.before,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _listSessionFilesDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return sessionDirectoryListResponseDeserializer(result.body);
+}
+/**
+ * Returns files and directories at the specified path in the session sandbox.
+ * The response includes only the immediate children of the target directory and defaults to the session home directory when no path is supplied.
+ */
+export function listSessionFiles(context, agentName, agentSessionId, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listSessionFilesSend(context, agentName, agentSessionId, options), _listSessionFilesDeserialize, ["200"], {
+        itemName: "entries",
+        apiVersion: context.apiVersion,
+        cursorFieldName: "last_id",
+        hasMoreFieldName: "has_more",
+    });
+}
+export function _downloadSessionFileSend(context, agentName, agentSessionId, path, options = { requestOptions: {} }) {
+    const path_1 = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions/{agent_session_id}/files/content{?path,api-version}", {
+        agent_name: agentName,
+        agent_session_id: agentSessionId,
+        path: path,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path_1).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/octet-stream",
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _downloadSessionFileDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };
+}
+/**
+ * Downloads the file at the specified sandbox path as a binary stream.
+ * The path is resolved relative to the session home directory.
+ */
+export async function downloadSessionFile(context, agentName, agentSessionId, path, options = { requestOptions: {} }) {
+    const streamableMethod = _downloadSessionFileSend(context, agentName, agentSessionId, path, options);
+    const result = await getBinaryStreamResponse(streamableMethod);
+    return _downloadSessionFileDeserialize(result);
+}
+export function _uploadSessionFileSend(context, agentName, agentSessionId, path, content, options = { requestOptions: {} }) {
+    const path_1 = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions/{agent_session_id}/files/content{?path,api-version}", {
+        agent_name: agentName,
+        agent_session_id: agentSessionId,
+        path: path,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path_1).put({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/octet-stream",
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: content,
+    });
+}
+export async function _uploadSessionFileDeserialize(result) {
+    const expectedStatuses = ["200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return sessionFileWriteResponseDeserializer(result.body);
+}
+/**
+ * Uploads binary file content to the specified path in the session sandbox.
+ * The service stores the file relative to the session home directory and rejects payloads larger than 50 MB.
+ */
+export async function uploadSessionFile(context, agentName, agentSessionId, path, content, options = { requestOptions: {} }) {
+    const result = await _uploadSessionFileSend(context, agentName, agentSessionId, path, content, options);
+    return _uploadSessionFileDeserialize(result);
+}
+export function _getSessionLogStreamSend(context, agentName, agentVersion, sessionId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/versions/{agent_version}/sessions/{session_id}:logstream{?api-version}", {
+        agent_name: agentName,
+        agent_version: agentVersion,
+        session_id: sessionId,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "text/event-stream", ...options.requestOptions?.headers },
+    });
+}
+export async function _getSessionLogStreamDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };
+}
+/**
+ * Streams console logs (stdout / stderr) for a specific hosted agent session
+ * as a Server-Sent Events (SSE) stream.
+ *
+ * Each SSE frame contains:
+ * - `event`: always `"log"`
+ * - `data`: a plain-text log line (currently JSON-formatted, but the schema
+ * is not contractual and may include additional keys or change format
+ * over time — clients should treat it as an opaque string)
+ *
+ * Example SSE frames:
+ * ```
+ * event: log
+ * data: {"timestamp":"2026-03-10T09:33:17.121Z","stream":"stdout","message":"Starting FoundryCBAgent server on port 8088"}
+ *
+ * event: log
+ * data: {"timestamp":"2026-03-10T09:33:17.130Z","stream":"stderr","message":"INFO: Application startup complete."}
+ *
+ * event: log
+ * data: {"timestamp":"2026-03-10T09:34:52.714Z","stream":"status","message":"Successfully connected to container"}
+ *
+ * event: log
+ * data: {"timestamp":"2026-03-10T09:35:52.714Z","stream":"status","message":"No logs since last 60 seconds"}
+ * ```
+ *
+ * The stream remains open until the client disconnects or the server
+ * terminates the connection. Clients should handle reconnection as needed.
+ */
+export async function getSessionLogStream(context, agentName, agentVersion, sessionId, options = { requestOptions: {} }) {
+    const streamableMethod = _getSessionLogStreamSend(context, agentName, agentVersion, sessionId, options);
+    const result = await getBinaryStreamResponse(streamableMethod);
+    return _getSessionLogStreamDeserialize(result);
+}
+export function _listSessionsSend(context, agentName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions{?limit,order,after,before,api-version}", {
+        agent_name: agentName,
+        limit: options?.limit,
+        order: options?.order,
+        after: options?.after,
+        before: options?.before,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _listSessionsDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return _agentsPagedResultAgentSessionResourceDeserializer(result.body);
+}
+/** Returns a paged collection of sessions associated with the specified agent endpoint. */
+export function listSessions(context, agentName, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listSessionsSend(context, agentName, options), _listSessionsDeserialize, ["200"], {
+        itemName: "data",
+        apiVersion: context.apiVersion,
+        cursorFieldName: "last_id",
+        hasMoreFieldName: "has_more",
+    });
+}
+export function _stopSessionSend(context, agentName, sessionId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions/{session_id}:stop{?api-version}", {
+        agent_name: agentName,
+        session_id: sessionId,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        headers: { ...options.requestOptions?.headers },
+    });
+}
+export async function _stopSessionDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return;
+}
+/** Terminates the specified hosted agent session and returns 204 No Content when the request succeeds. */
+export async function stopSession(context, agentName, sessionId, options = { requestOptions: {} }) {
+    const result = await _stopSessionSend(context, agentName, sessionId, options);
+    return _stopSessionDeserialize(result);
+}
+export function _deleteSessionSend(context, agentName, sessionId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions/{session_id}{?api-version}", {
+        agent_name: agentName,
+        session_id: sessionId,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).delete({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _deleteSessionDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return;
+}
+/**
+ * Deletes a session synchronously.
+ * Returns 204 No Content when the session is deleted or does not exist.
+ */
+export async function deleteSession(context, agentName, sessionId, options = { requestOptions: {} }) {
+    const result = await _deleteSessionSend(context, agentName, sessionId, options);
+    return _deleteSessionDeserialize(result);
+}
+export function _getSessionSend(context, agentName, sessionId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions/{session_id}{?api-version}", {
+        agent_name: agentName,
+        session_id: sessionId,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _getSessionDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return agentSessionResourceDeserializer(result.body);
+}
+/** Retrieves the details of a hosted agent session by agent name and session identifier. */
+export async function getSession(context, agentName, sessionId, options = { requestOptions: {} }) {
+    const result = await _getSessionSend(context, agentName, sessionId, options);
+    return _getSessionDeserialize(result);
+}
+export function _createSessionSend(context, agentName, versionIndicator, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/endpoint/sessions{?api-version}", {
+        agent_name: agentName,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: {
+            agent_session_id: options?.agentSessionId,
+            version_indicator: versionIndicatorUnionSerializer(versionIndicator),
+        },
+    });
+}
+export async function _createSessionDeserialize(result) {
+    const expectedStatuses = ["201"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return agentSessionResourceDeserializer(result.body);
+}
+/**
+ * Creates a new session for an agent endpoint.
+ * The endpoint resolves the backing agent version from `version_indicator` and
+ * enforces session ownership using the provided isolation key for session-mutating operations.
+ */
+export async function createSession(context, agentName, versionIndicator, options = { requestOptions: {} }) {
+    const result = await _createSessionSend(context, agentName, versionIndicator, options);
+    return _createSessionDeserialize(result);
+}
+export function _disableSend(context, agentName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}:disable{?api-version}", {
+        agent_name: agentName,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _disableDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return;
+}
+/**
+ * Disables the specified agent, preventing it from accepting new sessions or processing requests.
+ * Existing active sessions are allowed to drain gracefully but no new sessions can be created.
+ * This operation is idempotent — disabling an already-disabled agent returns success with no side effects.
+ */
+export async function disable(context, agentName, options = { requestOptions: {} }) {
+    const result = await _disableSend(context, agentName, options);
+    return _disableDeserialize(result);
+}
+export function _enableSend(context, agentName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}:enable{?api-version}", {
+        agent_name: agentName,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _enableDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return;
+}
+/**
+ * Enables the specified agent, allowing it to accept new sessions and process requests.
+ * This operation is idempotent — enabling an already-enabled agent returns success with no side effects.
+ */
+export async function enable(context, agentName, options = { requestOptions: {} }) {
+    const result = await _enableSend(context, agentName, options);
+    return _enableDeserialize(result);
+}
+export function _downloadAgentCodeSend(context, agentName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/code:download{?agent_version,api-version}", {
+        agent_name: agentName,
+        agent_version: options?.agentVersion,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/zip", ...options.requestOptions?.headers },
+    });
+}
+export async function _downloadAgentCodeDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body?.error) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };
+}
+/**
+ * Downloads the code zip for a code-based hosted agent.
+ * Returns the previously-uploaded zip (`application/zip`).
+ *
+ * If `agent_version` is supplied, returns that version's code zip; otherwise
+ * returns the latest version's code zip.
+ *
+ * The SHA-256 digest of the returned bytes matches the `content_hash` on the
+ * resolved version's `code_configuration`.
+ */
+export async function downloadAgentCode(context, agentName, options = { requestOptions: {} }) {
+    const streamableMethod = _downloadAgentCodeSend(context, agentName, options);
+    const result = await getBinaryStreamResponse(streamableMethod);
+    return _downloadAgentCodeDeserialize(result);
+}
+export function _createVersionFromCodeSend(context, agentName, codeZipSha256, content, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}/versions{?api-version}", {
+        agent_name: agentName,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "multipart/form-data",
+        headers: {
+            "x-ms-code-zip-sha256": codeZipSha256,
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: createAgentVersionFromCodeContentSerializer(content),
+    });
+}
+export async function _createVersionFromCodeDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return agentVersionDeserializer(result.body);
+}
+/**
+ * Creates a new agent version from code. Uploads the code zip and creates a new version
+ * for an existing agent. The SHA-256 hex digest of the zip is provided in the
+ * `x-ms-code-zip-sha256` header for integrity and dedup.
+ * The request body is multipart/form-data with a JSON metadata part and a binary code part (part order is irrelevant).
+ * Maximum upload size is 250 MB.
+ */
+export async function createVersionFromCode(context, agentName, codeZipSha256, content, options = { requestOptions: {} }) {
+    const result = await _createVersionFromCodeSend(context, agentName, codeZipSha256, content, options);
+    return _createVersionFromCodeDeserialize(result);
+}
+export function _patchAgentObjectSend(context, agentName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}{?api-version}", {
+        agent_name: agentName,
+        "api-version": context.apiVersion,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).patch({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/merge-patch+json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: {
+            agent_endpoint: !options?.agentEndpoint
+                ? options?.agentEndpoint
+                : agentEndpointConfigSerializer(options?.agentEndpoint),
+            agent_card: !options?.agentCard
+                ? options?.agentCard
+                : agentCardSerializer(options?.agentCard),
+        },
+    });
+}
+export async function _patchAgentObjectDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        const error = createRestError(result);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
+        throw error;
+    }
+    return agentDeserializer(result.body);
+}
+/** Applies a merge-patch update to the specified agent endpoint configuration. */
+export async function updateAgentObject(context, agentName, options = { requestOptions: {} }) {
+    const result = await _patchAgentObjectSend(context, agentName, options);
+    return _patchAgentObjectDeserialize(result);
+}
 export function _listVersionsSend(context, agentName, options = { requestOptions: {} }) {
     const path = expandUrlTemplate("/agents/{agent_name}/versions{?limit,order,after,before,api-version}", {
         agent_name: agentName,
@@ -24,12 +584,14 @@ export async function _listVersionsDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return _agentsPagedResultAgentVersionObjectDeserializer(result.body);
 }
-/** Returns the list of versions of an agent. */
+/** Returns a paged collection of versions for the specified agent. */
 export function listVersions(context, agentName, options = { requestOptions: {} }) {
     return buildPagedAsyncIterator(context, () => _listVersionsSend(context, agentName, options), _listVersionsDeserialize, ["200"], {
         itemName: "data",
@@ -39,9 +601,10 @@ export function listVersions(context, agentName, options = { requestOptions: {}
     });
 }
 export function _deleteVersionSend(context, agentName, agentVersion, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents/{agent_name}/versions/{agent_version}{?api-version}", {
+    const path = expandUrlTemplate("/agents/{agent_name}/versions/{agent_version}{?force,api-version}", {
         agent_name: agentName,
         agent_version: agentVersion,
+        force: options?.force,
         "api-version": context.apiVersion,
     }, {
         allowReserved: options?.requestOptions?.skipUrlEncoding,
@@ -55,12 +618,18 @@ export async function _deleteVersionDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return deleteAgentVersionResponseDeserializer(result.body);
 }
-/** Deletes a specific version of an agent. */
+/**
+ * Deletes a specific version of an agent. For hosted agents, if the version has active
+ * sessions, the request is rejected with HTTP 409 unless `force` is set to true. When
+ * force is true, all sessions associated with this version are cascade-deleted.
+ */
 export async function deleteVersion(context, agentName, agentVersion, options = { requestOptions: {} }) {
     const result = await _deleteVersionSend(context, agentName, agentVersion, options);
     return _deleteVersionDeserialize(result);
@@ -82,12 +651,14 @@ export async function _getVersionDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentVersionDeserializer(result.body);
 }
-/** Retrieves a specific version of an agent. */
+/** Retrieves the specified version of an agent by its agent name and version identifier. */
 export async function getVersion(context, agentName, agentVersion, options = { requestOptions: {} }) {
     const result = await _getVersionSend(context, agentName, agentVersion, options);
     return _getVersionDeserialize(result);
@@ -115,15 +686,30 @@ export async function _createAgentVersionFromManifestDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentVersionDeserializer(result.body);
 }
-/** Create a new agent version from a manifest. */
-export async function createAgentVersionFromManifest(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
-    const result = await _createAgentVersionFromManifestSend(context, agentName, manifestId, parameterValues, options);
-    return _createAgentVersionFromManifestDeserialize(result);
+/** Imports the provided manifest to create a new version for the specified agent. */
+export async function createAgentVersionFromManifest(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }, tracingConfig) {
+    if (!tracingConfig?.enabled) {
+        const result = await _createAgentVersionFromManifestSend(context, agentName, manifestId, parameterValues, options);
+        return _createAgentVersionFromManifestDeserialize(result);
+    }
+    const { span } = startSpan(`${OperationName.CREATE_AGENT} ${agentName}`);
+    try {
+        setCommonAttributes(span, OperationName.CREATE_AGENT, context.endpoint);
+        const result = await _createAgentVersionFromManifestSend(context, agentName, manifestId, parameterValues, options);
+        const version = await _createAgentVersionFromManifestDeserialize(result);
+        setAgentVersionAttributes(span, version, tracingConfig.contentRecording);
+        return version;
+    }
+    finally {
+        span.end();
+    }
 }
 export function _createVersionSend(context, agentName, definition, options = { requestOptions: {} }) {
     const path = expandUrlTemplate("/agents/{agent_name}/versions{?api-version}", {
@@ -137,7 +723,7 @@ export function _createVersionSend(context, agentName, definition, options = { r
         contentType: "application/json",
         headers: {
             ...(options?.foundryFeatures !== undefined
-                ? { "foundry-features": `${options?.foundryFeatures},AgentEndpoints=V1Preview` }
+                ? { "foundry-features": `${options?.foundryFeatures}` }
                 : {}),
             accept: "application/json",
             ...options.requestOptions?.headers,
@@ -156,15 +742,30 @@ export async function _createVersionDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentVersionDeserializer(result.body);
 }
-/** Create a new agent version. */
-export async function createVersion(context, agentName, definition, options = { requestOptions: {} }) {
-    const result = await _createVersionSend(context, agentName, definition, options);
-    return _createVersionDeserialize(result);
+/** Creates a new version for the specified agent and returns the created version resource. */
+export async function createVersion(context, agentName, definition, options = { requestOptions: {} }, tracingConfig) {
+    if (!tracingConfig?.enabled) {
+        const result = await _createVersionSend(context, agentName, definition, options);
+        return _createVersionDeserialize(result);
+    }
+    const { span } = startSpan(`${OperationName.CREATE_AGENT} ${agentName}`);
+    try {
+        setCommonAttributes(span, OperationName.CREATE_AGENT, context.endpoint);
+        const result = await _createVersionSend(context, agentName, definition, options);
+        const version = await _createVersionDeserialize(result);
+        setAgentVersionAttributes(span, version, tracingConfig.contentRecording);
+        return version;
+    }
+    finally {
+        span.end();
+    }
 }
 export function _listSend(context, options = { requestOptions: {} }) {
     const path = expandUrlTemplate("/agents{?kind,limit,order,after,before,api-version}", {
@@ -186,12 +787,14 @@ export async function _listDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return _agentsPagedResultAgentObjectDeserializer(result.body);
 }
-/** Returns the list of all agents. */
+/** Returns a paged collection of agent resources. */
 export function list(context, options = { requestOptions: {} }) {
     return buildPagedAsyncIterator(context, () => _listSend(context, options), _listDeserialize, ["200"], {
         itemName: "data",
@@ -200,9 +803,10 @@ export function list(context, options = { requestOptions: {} }) {
         hasMoreFieldName: "has_more",
     });
 }
-export function _deleteSend(context, agentName, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents/{agent_name}{?api-version}", {
+export function _$deleteSend(context, agentName, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/agents/{agent_name}{?force,api-version}", {
         agent_name: agentName,
+        force: options?.force,
         "api-version": context.apiVersion,
     }, {
         allowReserved: options?.requestOptions?.skipUrlEncoding,
@@ -212,19 +816,25 @@ export function _deleteSend(context, agentName, options = { requestOptions: {} }
         headers: { accept: "application/json", ...options.requestOptions?.headers },
     });
 }
-export async function _deleteDeserialize(result) {
+export async function _$deleteDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return deleteAgentResponseDeserializer(result.body);
 }
-/** Deletes an agent. */
+/**
+ * Deletes an agent. For hosted agents, if any version has active sessions, the request
+ * is rejected with HTTP 409 unless `force` is set to true. When force is true, all
+ * associated sessions are cascade-deleted along with the agent and its versions.
+ */
 export async function $delete(context, agentName, options = { requestOptions: {} }) {
-    const result = await _deleteSend(context, agentName, options);
-    return _deleteDeserialize(result);
+    const result = await _$deleteSend(context, agentName, options);
+    return _$deleteDeserialize(result);
 }
 export function _updateAgentFromManifestSend(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
     const path = expandUrlTemplate("/agents/{agent_name}/import{?api-version}", {
@@ -249,7 +859,9 @@ export async function _updateAgentFromManifestDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentDeserializer(result.body);
@@ -258,7 +870,7 @@ export async function _updateAgentFromManifestDeserialize(result) {
  * Updates the agent from a manifest by adding a new version if there are any changes to the agent definition.
  * If no changes, returns the existing agent version.
  */
-export async function updateAgentFromManifest(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
+export async function updateAgentFromManifest(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }, _tracingConfig) {
     const result = await _updateAgentFromManifestSend(context, agentName, manifestId, parameterValues, options);
     return _updateAgentFromManifestDeserialize(result);
 }
@@ -285,15 +897,30 @@ export async function _createAgentFromManifestDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentDeserializer(result.body);
 }
-/** Creates an agent from a manifest. */
-export async function createAgentFromManifest(context, name, manifestId, parameterValues, options = { requestOptions: {} }) {
-    const result = await _createAgentFromManifestSend(context, name, manifestId, parameterValues, options);
-    return _createAgentFromManifestDeserialize(result);
+/** Imports the provided manifest to create an agent and returns the created resource. */
+export async function createAgentFromManifest(context, name, manifestId, parameterValues, options = { requestOptions: {} }, tracingConfig) {
+    if (!tracingConfig?.enabled) {
+        const result = await _createAgentFromManifestSend(context, name, manifestId, parameterValues, options);
+        return _createAgentFromManifestDeserialize(result);
+    }
+    const { span } = startSpan(`${OperationName.CREATE_AGENT} ${name}`);
+    try {
+        setCommonAttributes(span, OperationName.CREATE_AGENT, context.endpoint);
+        const result = await _createAgentFromManifestSend(context, name, manifestId, parameterValues, options);
+        const agent = await _createAgentFromManifestDeserialize(result);
+        setAgentAttributes(span, agent, tracingConfig.contentRecording);
+        return agent;
+    }
+    finally {
+        span.end();
+    }
 }
 export function _updateSend(context, agentName, definition, options = { requestOptions: {} }) {
     const path = expandUrlTemplate("/agents/{agent_name}{?api-version}", {
@@ -307,7 +934,7 @@ export function _updateSend(context, agentName, definition, options = { requestO
         contentType: "application/json",
         headers: {
             ...(options?.foundryFeatures !== undefined
-                ? { "foundry-features": `${options?.foundryFeatures},AgentEndpoints=V1Preview` }
+                ? { "foundry-features": `${options?.foundryFeatures}` }
                 : {}),
             accept: "application/json",
             ...options.requestOptions?.headers,
@@ -326,7 +953,9 @@ export async function _updateDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentDeserializer(result.body);
@@ -335,7 +964,7 @@ export async function _updateDeserialize(result) {
  * Updates the agent by adding a new version if there are any changes to the agent definition.
  * If no changes, returns the existing agent version.
  */
-export async function update(context, agentName, definition, options = { requestOptions: {} }) {
+export async function update(context, agentName, definition, options = { requestOptions: {} }, _tracingConfig) {
     const result = await _updateSend(context, agentName, definition, options);
     return _updateDeserialize(result);
 }
@@ -350,13 +979,14 @@ export function _createSend(context, name, definition, options = { requestOption
         contentType: "application/json",
         headers: {
             ...(options?.foundryFeatures !== undefined
-                ? { "foundry-features": `${options?.foundryFeatures},AgentEndpoints=V1Preview` }
+                ? { "foundry-features": `${options?.foundryFeatures}` }
                 : {}),
             accept: "application/json",
             ...options.requestOptions?.headers,
         },
         body: {
             name: name,
+            state: options?.state,
             metadata: options?.metadata,
             description: options?.description,
             definition: agentDefinitionUnionSerializer(definition),
@@ -365,7 +995,7 @@ export function _createSend(context, name, definition, options = { requestOption
                 : agentBlueprintReferenceUnionSerializer(options?.blueprintReference),
             agent_endpoint: !options?.agentEndpoint
                 ? options?.agentEndpoint
-                : agentEndpointSerializer(options?.agentEndpoint),
+                : agentEndpointConfigSerializer(options?.agentEndpoint),
             agent_card: !options?.agentCard
                 ? options?.agentCard
                 : agentCardSerializer(options?.agentCard),
@@ -376,15 +1006,30 @@ export async function _createDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentDeserializer(result.body);
 }
-/** Creates the agent. */
-export async function create(context, name, definition, options = { requestOptions: {} }) {
-    const result = await _createSend(context, name, definition, options);
-    return _createDeserialize(result);
+/** Creates a new agent or a new version of an existing agent. */
+export async function create(context, name, definition, options = { requestOptions: {} }, tracingConfig) {
+    if (!tracingConfig?.enabled) {
+        const result = await _createSend(context, name, definition, options);
+        return _createDeserialize(result);
+    }
+    const { span } = startSpan(`${OperationName.CREATE_AGENT} ${name}`);
+    try {
+        setCommonAttributes(span, OperationName.CREATE_AGENT, context.endpoint);
+        const result = await _createSend(context, name, definition, options);
+        const agent = await _createDeserialize(result);
+        setAgentAttributes(span, agent, tracingConfig.contentRecording);
+        return agent;
+    }
+    finally {
+        span.end();
+    }
 }
 export function _getSend(context, agentName, options = { requestOptions: {} }) {
     const path = expandUrlTemplate("/agents/{agent_name}{?api-version}", {
@@ -402,12 +1047,14 @@ export async function _getDeserialize(result) {
     const expectedStatuses = ["200"];
     if (!expectedStatuses.includes(result.status)) {
         const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
+        if (result.body) {
+            error.details = apiErrorResponseDeserializer(result.body);
+        }
         throw error;
     }
     return agentDeserializer(result.body);
 }
-/** Retrieves the agent. */
+/** Retrieves an agent definition by its unique name. */
 export async function get(context, agentName, options = { requestOptions: {} }) {
     const result = await _getSend(context, agentName, options);
     return _getDeserialize(result);