@azure/ai-projects 2.0.0-beta.4 → 2.0.0

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

@@ -1,457 +1,488 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-/* eslint-disable tsdoc/syntax */
-import { agentObjectDeserializer, agentVersionObjectDeserializer, agentDefinitionUnionSerializer, apiErrorResponseDeserializer, deleteAgentResponseDeserializer, _agentsPagedResultAgentObjectDeserializer, deleteAgentVersionResponseDeserializer, _agentsPagedResultAgentVersionObjectDeserializer, } from "../../models/models.js";
-import { buildPagedAsyncIterator, } from "../../static-helpers/pagingHelpers.js";
+import {
+  agentDeserializer,
+  agentVersionDeserializer,
+  agentDefinitionUnionSerializer,
+  apiErrorResponseDeserializer,
+  deleteAgentResponseDeserializer,
+  _agentsPagedResultAgentObjectDeserializer,
+  deleteAgentVersionResponseDeserializer,
+  _agentsPagedResultAgentVersionObjectDeserializer
+} 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";
-export function _streamAgentContainerLogsSend(context, agentName, agentVersion, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents/{agent_name}/versions/{agent_version}/containers/default:logstream{?api-version,kind,replica_name,tail}", {
-        agent_name: agentName,
-        agent_version: agentVersion,
-        "api-version": context.apiVersion,
-        kind: options?.kind,
-        replica_name: options?.replicaName,
-        tail: options?.tail,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).post({ ...operationOptionsToRequestParameters(options) });
-}
-export async function _streamAgentContainerLogsDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+import { createRestError, operationOptionsToRequestParameters } from "@azure-rest/core-client";
+function _listVersionsSend(context, agentName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}/versions{?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 ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return;
-}
-/**
- * Container log entry streamed from the container as text chunks.
- * Each chunk is a UTF-8 string that may be either a plain text log line
- * or a JSON-formatted log entry, depending on the type of container log being streamed.
- * Clients should treat each chunk as opaque text and, if needed, attempt
- * to parse it as JSON based on their logging requirements.
- *
- * For system logs, the format is JSON with the following structure:
- * {"TimeStamp":"2025-12-15T16:51:33Z","Type":"Normal","ContainerAppName":null,"RevisionName":null,"ReplicaName":null,"Msg":"Connecting to the events collector...","Reason":"StartingGettingEvents","EventSource":"ContainerAppController","Count":1}
- * {"TimeStamp":"2025-12-15T16:51:34Z","Type":"Normal","ContainerAppName":null,"RevisionName":null,"ReplicaName":null,"Msg":"Successfully connected to events server","Reason":"ConnectedToEventsServer","EventSource":"ContainerAppController","Count":1}
- *
- * For console logs, the format is plain text as emitted by the container's stdout/stderr.
- * 2025-12-15T08:43:48.72656  Connecting to the container 'agent-container'...
- * 2025-12-15T08:43:48.75451  Successfully Connected to container: 'agent-container' [Revision: 'je90fe655aa742ef9a188b9fd14d6764--7tca06b', Replica: 'je90fe655aa742ef9a188b9fd14d6764--7tca06b-6898b9c89f-mpkjc']
- * 2025-12-15T08:33:59.0671054Z stdout F INFO:     127.0.0.1:42588 - "GET /readiness HTTP/1.1" 200 OK
- * 2025-12-15T08:34:29.0649033Z stdout F INFO:     127.0.0.1:60246 - "GET /readiness HTTP/1.1" 200 OK
- * 2025-12-15T08:34:59.0644467Z stdout F INFO:     127.0.0.1:43994 - "GET /readiness HTTP/1.1" 200 OK
- */
-export async function streamAgentContainerLogs(context, agentName, agentVersion, options = { requestOptions: {} }) {
-    const result = await _streamAgentContainerLogsSend(context, agentName, agentVersion, options);
-    return _streamAgentContainerLogsDeserialize(result);
-}
-export function _listAgentVersionsSend(context, agentName, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents/{agent_name}/versions{?api-version,limit,order,after,before}", {
-        agent_name: agentName,
-        "api-version": context.apiVersion,
-        limit: options?.limit,
-        order: options?.order,
-        after: options?.after,
-        before: options?.before,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).get({
-        ...operationOptionsToRequestParameters(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
-}
-export async function _listAgentVersionsDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listVersionsDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return _agentsPagedResultAgentVersionObjectDeserializer(result.body);
+}
+function listVersions(context, agentName, options = { requestOptions: {} }) {
+  return buildPagedAsyncIterator(
+    context,
+    () => _listVersionsSend(context, agentName, options),
+    _listVersionsDeserialize,
+    ["200"],
+    { itemName: "data", apiVersion: context.apiVersion ?? "v1" }
+  );
+}
+function _deleteVersionSend(context, agentName, agentVersion, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}/versions/{agent_version}{?api-version}",
+    {
+      agent_name: agentName,
+      agent_version: agentVersion,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return _agentsPagedResultAgentVersionObjectDeserializer(result.body);
-}
-/** Returns the list of versions of an agent. */
-export function listAgentVersions(context, agentName, options = { requestOptions: {} }) {
-    return buildPagedAsyncIterator(context, () => _listAgentVersionsSend(context, agentName, options), _listAgentVersionsDeserialize, ["200"], { itemName: "data" });
-}
-export function _deleteAgentVersionSend(context, agentName, agentVersion, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents/{agent_name}/versions/{agent_version}{?api-version}", {
-        agent_name: agentName,
-        agent_version: agentVersion,
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).delete({
-        ...operationOptionsToRequestParameters(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
-}
-export async function _deleteAgentVersionDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).delete({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _deleteVersionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return deleteAgentVersionResponseDeserializer(result.body);
+}
+async function deleteVersion(context, agentName, agentVersion, options = { requestOptions: {} }) {
+  const result = await _deleteVersionSend(context, agentName, agentVersion, options);
+  return _deleteVersionDeserialize(result);
+}
+function _getVersionSend(context, agentName, agentVersion, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}/versions/{agent_version}{?api-version}",
+    {
+      agent_name: agentName,
+      agent_version: agentVersion,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return deleteAgentVersionResponseDeserializer(result.body);
-}
-/** Deletes a specific version of an agent. */
-export async function deleteAgentVersion(context, agentName, agentVersion, options = { requestOptions: {} }) {
-    const result = await _deleteAgentVersionSend(context, agentName, agentVersion, options);
-    return _deleteAgentVersionDeserialize(result);
-}
-export function _getAgentVersionSend(context, agentName, agentVersion, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents/{agent_name}/versions/{agent_version}{?api-version}", {
-        agent_name: agentName,
-        agent_version: agentVersion,
-        "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 _getAgentVersionDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getVersionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentVersionDeserializer(result.body);
+}
+async function getVersion(context, agentName, agentVersion, options = { requestOptions: {} }) {
+  const result = await _getVersionSend(context, agentName, agentVersion, options);
+  return _getVersionDeserialize(result);
+}
+function _createAgentVersionFromManifestSend(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}/versions:import{?api-version}",
+    {
+      agent_name: agentName,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return agentVersionObjectDeserializer(result.body);
-}
-/** Retrieves a specific version of an agent. */
-export async function getAgentVersion(context, agentName, agentVersion, options = { requestOptions: {} }) {
-    const result = await _getAgentVersionSend(context, agentName, agentVersion, options);
-    return _getAgentVersionDeserialize(result);
-}
-export function _createAgentVersionSend(context, agentName, definition, 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: "application/json",
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-        body: {
-            description: options?.description,
-            metadata: options?.metadata,
-            definition: agentDefinitionUnionSerializer(definition),
-        },
-    });
-}
-export async function _createAgentVersionDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: {
+      metadata: options?.metadata,
+      description: options?.description,
+      manifest_id: manifestId,
+      parameter_values: parameterValues
     }
-    return agentVersionObjectDeserializer(result.body);
-}
-/** Create a new agent version. */
-export async function createAgentVersion(context, agentName, definition, options = { requestOptions: {} }) {
-    const result = await _createAgentVersionSend(context, agentName, definition, options);
-    return _createAgentVersionDeserialize(result);
-}
-export function _listAgentsSend(context, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents{?api-version,kind,limit,order,after,before}", {
-        "api-version": context.apiVersion,
-        kind: options?.kind,
-        limit: options?.limit,
-        order: options?.order,
-        after: options?.after,
-        before: options?.before,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).get({
-        ...operationOptionsToRequestParameters(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
-}
-export async function _listAgentsDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  });
+}
+async function _createAgentVersionFromManifestDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentVersionDeserializer(result.body);
+}
+async function createAgentVersionFromManifest(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
+  const result = await _createAgentVersionFromManifestSend(
+    context,
+    agentName,
+    manifestId,
+    parameterValues,
+    options
+  );
+  return _createAgentVersionFromManifestDeserialize(result);
+}
+function _createVersionSend(context, agentName, definition, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}/versions{?api-version}",
+    {
+      agent_name: agentName,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return _agentsPagedResultAgentObjectDeserializer(result.body);
-}
-/** Returns the list of all agents. */
-export function listAgents(context, options = { requestOptions: {} }) {
-    return buildPagedAsyncIterator(context, () => _listAgentsSend(context, options), _listAgentsDeserialize, ["200"], { itemName: "data" });
-}
-export function _deleteAgentSend(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).delete({
-        ...operationOptionsToRequestParameters(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
-}
-export async function _deleteAgentDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: {
+      ...options?.foundryFeatures !== void 0 ? { "foundry-features": options?.foundryFeatures } : {},
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    },
+    body: {
+      metadata: options?.metadata,
+      description: options?.description,
+      definition: agentDefinitionUnionSerializer(definition)
     }
-    return deleteAgentResponseDeserializer(result.body);
-}
-/** Deletes an agent. */
-export async function deleteAgent(context, agentName, options = { requestOptions: {} }) {
-    const result = await _deleteAgentSend(context, agentName, options);
-    return _deleteAgentDeserialize(result);
-}
-export function _updateAgentFromManifestSend(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents/{agent_name}/import{?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: {
-            description: options?.description,
-            metadata: options?.metadata,
-            manifest_id: manifestId,
-            parameter_values: parameterValues,
-        },
-    });
-}
-export async function _updateAgentFromManifestDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  });
+}
+async function _createVersionDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentVersionDeserializer(result.body);
+}
+async function createVersion(context, agentName, definition, options = { requestOptions: {} }) {
+  const result = await _createVersionSend(context, agentName, definition, options);
+  return _createVersionDeserialize(result);
+}
+function _listSend(context, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents{?kind,limit,order,after,before,api-version}",
+    {
+      kind: options?.kind,
+      limit: options?.limit,
+      order: options?.order,
+      after: options?.after,
+      before: options?.before,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return agentObjectDeserializer(result.body);
-}
-/**
- * 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: {} }) {
-    const result = await _updateAgentFromManifestSend(context, agentName, manifestId, parameterValues, options);
-    return _updateAgentFromManifestDeserialize(result);
-}
-export function _createAgentFromManifestSend(context, name, manifestId, parameterValues, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents:import{?api-version}", {
-        "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: {
-            name: name,
-            description: options?.description,
-            metadata: options?.metadata,
-            manifest_id: manifestId,
-            parameter_values: parameterValues,
-        },
-    });
-}
-export async function _createAgentFromManifestDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _listDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return _agentsPagedResultAgentObjectDeserializer(result.body);
+}
+function list(context, options = { requestOptions: {} }) {
+  return buildPagedAsyncIterator(
+    context,
+    () => _listSend(context, options),
+    _listDeserialize,
+    ["200"],
+    { itemName: "data", apiVersion: context.apiVersion ?? "v1" }
+  );
+}
+function _deleteSend(context, agentName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}{?api-version}",
+    {
+      agent_name: agentName,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return agentObjectDeserializer(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);
-}
-export function _updateAgentSend(context, agentName, definition, 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).post({
-        ...operationOptionsToRequestParameters(options),
-        contentType: "application/json",
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-        body: {
-            description: options?.description,
-            metadata: options?.metadata,
-            definition: agentDefinitionUnionSerializer(definition),
-        },
-    });
-}
-export async function _updateAgentDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).delete({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _deleteDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return deleteAgentResponseDeserializer(result.body);
+}
+async function $delete(context, agentName, options = { requestOptions: {} }) {
+  const result = await _deleteSend(context, agentName, options);
+  return _deleteDeserialize(result);
+}
+function _updateAgentFromManifestSend(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}/import{?api-version}",
+    {
+      agent_name: agentName,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return agentObjectDeserializer(result.body);
-}
-/**
- * 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 updateAgent(context, agentName, definition, options = { requestOptions: {} }) {
-    const result = await _updateAgentSend(context, agentName, definition, options);
-    return _updateAgentDeserialize(result);
-}
-export function _createAgentSend(context, name, definition, options = { requestOptions: {} }) {
-    const path = expandUrlTemplate("/agents{?api-version}", {
-        "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: {
-            name: name,
-            description: options?.description,
-            metadata: options?.metadata,
-            definition: agentDefinitionUnionSerializer(definition),
-        },
-    });
-}
-export async function _createAgentDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: {
+      metadata: options?.metadata,
+      description: options?.description,
+      manifest_id: manifestId,
+      parameter_values: parameterValues
     }
-    return agentObjectDeserializer(result.body);
-}
-/** Creates the agent. */
-export async function createAgent(context, name, definition, options = { requestOptions: {} }) {
-    const result = await _createAgentSend(context, name, definition, options);
-    return _createAgentDeserialize(result);
-}
-export function _getAgentSend(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).get({
-        ...operationOptionsToRequestParameters(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
-}
-export async function _getAgentDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  });
+}
+async function _updateAgentFromManifestDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentDeserializer(result.body);
+}
+async function updateAgentFromManifest(context, agentName, manifestId, parameterValues, options = { requestOptions: {} }) {
+  const result = await _updateAgentFromManifestSend(
+    context,
+    agentName,
+    manifestId,
+    parameterValues,
+    options
+  );
+  return _updateAgentFromManifestDeserialize(result);
+}
+function _createAgentFromManifestSend(context, name, manifestId, parameterValues, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents:import{?api-version}",
+    {
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
     }
-    return agentObjectDeserializer(result.body);
-}
-/** Retrieves the agent. */
-export async function getAgent(context, agentName, options = { requestOptions: {} }) {
-    const result = await _getAgentSend(context, agentName, options);
-    return _getAgentDeserialize(result);
-}
-export function _createAgentVersionFromManifestSend(context, agentName, manifestId, parameterValues, options = {
-    requestOptions: {},
-}) {
-    const path = expandUrlTemplate("/agents/{agent_name}/versions:import{?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: {
-            description: options?.description,
-            metadata: options?.metadata,
-            manifest_id: manifestId,
-            parameter_values: parameterValues,
-        },
-    });
-}
-export async function _createAgentVersionFromManifestDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        const error = createRestError(result);
-        error.details = apiErrorResponseDeserializer(result.body);
-        throw error;
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: { accept: "application/json", ...options.requestOptions?.headers },
+    body: {
+      name,
+      metadata: options?.metadata,
+      description: options?.description,
+      manifest_id: manifestId,
+      parameter_values: parameterValues
     }
-    return agentVersionObjectDeserializer(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);
-}
-//# sourceMappingURL=operations.js.map
+  });
+}
+async function _createAgentFromManifestDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentDeserializer(result.body);
+}
+async function createAgentFromManifest(context, name, manifestId, parameterValues, options = { requestOptions: {} }) {
+  const result = await _createAgentFromManifestSend(
+    context,
+    name,
+    manifestId,
+    parameterValues,
+    options
+  );
+  return _createAgentFromManifestDeserialize(result);
+}
+function _updateSend(context, agentName, definition, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}{?api-version}",
+    {
+      agent_name: agentName,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: {
+      ...options?.foundryFeatures !== void 0 ? { "foundry-features": options?.foundryFeatures } : {},
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    },
+    body: {
+      metadata: options?.metadata,
+      description: options?.description,
+      definition: agentDefinitionUnionSerializer(definition)
+    }
+  });
+}
+async function _updateDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentDeserializer(result.body);
+}
+async function update(context, agentName, definition, options = { requestOptions: {} }) {
+  const result = await _updateSend(context, agentName, definition, options);
+  return _updateDeserialize(result);
+}
+function _createSend(context, name, definition, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents{?api-version}",
+    {
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...operationOptionsToRequestParameters(options),
+    contentType: "application/json",
+    headers: {
+      ...options?.foundryFeatures !== void 0 ? { "foundry-features": options?.foundryFeatures } : {},
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    },
+    body: {
+      name,
+      metadata: options?.metadata,
+      description: options?.description,
+      definition: agentDefinitionUnionSerializer(definition)
+    }
+  });
+}
+async function _createDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentDeserializer(result.body);
+}
+async function create(context, name, definition, options = { requestOptions: {} }) {
+  const result = await _createSend(context, name, definition, options);
+  return _createDeserialize(result);
+}
+function _getSend(context, agentName, options = { requestOptions: {} }) {
+  const path = expandUrlTemplate(
+    "/agents/{agent_name}{?api-version}",
+    {
+      agent_name: agentName,
+      "api-version": context.apiVersion ?? "v1"
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...operationOptionsToRequestParameters(options),
+    headers: { accept: "application/json", ...options.requestOptions?.headers }
+  });
+}
+async function _getDeserialize(result) {
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = apiErrorResponseDeserializer(result.body);
+    throw error;
+  }
+  return agentDeserializer(result.body);
+}
+async function get(context, agentName, options = { requestOptions: {} }) {
+  const result = await _getSend(context, agentName, options);
+  return _getDeserialize(result);
+}
+export {
+  $delete,
+  _createAgentFromManifestDeserialize,
+  _createAgentFromManifestSend,
+  _createAgentVersionFromManifestDeserialize,
+  _createAgentVersionFromManifestSend,
+  _createDeserialize,
+  _createSend,
+  _createVersionDeserialize,
+  _createVersionSend,
+  _deleteDeserialize,
+  _deleteSend,
+  _deleteVersionDeserialize,
+  _deleteVersionSend,
+  _getDeserialize,
+  _getSend,
+  _getVersionDeserialize,
+  _getVersionSend,
+  _listDeserialize,
+  _listSend,
+  _listVersionsDeserialize,
+  _listVersionsSend,
+  _updateAgentFromManifestDeserialize,
+  _updateAgentFromManifestSend,
+  _updateDeserialize,
+  _updateSend,
+  create,
+  createAgentFromManifest,
+  createAgentVersionFromManifest,
+  createVersion,
+  deleteVersion,
+  get,
+  getVersion,
+  list,
+  listVersions,
+  update,
+  updateAgentFromManifest
+};