Implementación de un agente hospedado desde el código fuente

• pip desde Python 3.13 o una versión posterior, para empaquetar tu código fuente localmente.

• La versión azure-ai-projects 2.2.0 o posterior y los paquetes azure-identity.

  pip install "azure-ai-projects>=2.2.0" azure-identity
  

• El SDK de .NET 10 para empaquetar tu código fuente localmente.

• Los paquetes Azure.AI.Projects.Agents y Azure.Identity.

  dotnet add package Azure.AI.Projects.Agents --prerelease
  dotnet add package Azure.Identity
  

  Note

  Las API de implementación de código fuente para .NET solo están disponibles actualmente en una versión preliminar de Azure.AI.Projects.Agents. Use la --prerelease marca para instalarla. Estas API aún no se incluyen en la versión estable (GA).

• Node.js 22 o posterior, para empaquetar el origen localmente.

• Los paquetes @azure/ai-projects y @azure/identity. Ejecutas el llamador en Node.js, pero el entorno de ejecución alojado que despliegas sigue siendo código fuente de Python o .NET.

  npm install @azure/ai-projects @azure/identity
  

• Un cliente HTTP de línea de comandos como curl (los ejemplos rest de este artículo usan curl).
• Para empaquetar tu código fuente localmente, instala el conjunto de herramientas correspondiente al lenguaje de tu agente: pip Python 3.13 o posterior, o el SDK de .NET 10.

Use el SDK de Python para implementar agentes de código fuente desde sus propias aplicaciones o automatización. Compile el archivo ZIP y pase sus bytes y SHA-256 al SDK, que lo carga y expone las mismas operaciones de creación, sondeo, invocación y descarga que la API REST. El despliegue de código requiere la versión 2.2.0 o posterior de azure-ai-projects.

Compilación del archivo ZIP

El SDK de Python sube un archivo ZIP que creas. Use las mismas reglas de diseño y resolución de dependencias descritas en Empaquetar el archivo ZIP manualmente. La carga mínima remote_build es un zip plano con main.py y requirements.txt en la raíz.

Creación del agente

import hashlib
from pathlib import Path

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    CodeConfiguration,
    HostedAgentDefinition,
    ProtocolVersionRecord,
)
from azure.identity import DefaultAzureCredential

# Format: "https://<account>.services.ai.azure.com/api/projects/<project>"
PROJECT_ENDPOINT = "your_project_endpoint"
AGENT_NAME = "my-code-agent"
ZIP_PATH = Path("agent-code.zip")

code_zip_bytes = ZIP_PATH.read_bytes()
code_zip_sha256 = hashlib.sha256(code_zip_bytes).hexdigest()

credential = DefaultAzureCredential()
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=credential,
)

created = project.agents.create_version_from_code(
    agent_name=AGENT_NAME,
    definition=HostedAgentDefinition(
        cpu="1",
        memory="2Gi",
        code_configuration=CodeConfiguration(
            runtime="python_3_13",
            entry_point=["python", "main.py"],
            dependency_resolution="remote_build",
        ),
        protocol_versions=[
            ProtocolVersionRecord(protocol="responses", version="1.0.0")
        ],
        environment_variables={"AZURE_AI_MODEL_DEPLOYMENT_NAME": "gpt-5.4-mini"},
    ),
    code=(ZIP_PATH.name, code_zip_bytes, "application/zip"),
    code_zip_sha256=code_zip_sha256,
    description="Hello-world code agent",
)
print(f"Created version: {created.version}")

Para el protocolo Invocations, establezca la entrada protocol_versions en ProtocolVersionRecord(protocol="invocations", version="1.0.0"). Para el protocolo Invocations (WebSocket), utilice ProtocolVersionRecord(protocol="invocations_ws", version="1.0.0"). Para el modo bundled, establezca dependency_resolution="bundled" e incluya las dependencias precompiladas en el archivo ZIP. Para obtener más información, consulte Compilación de dependencias de Linux localmente.

Sondear por activo

import time

while True:
    version = project.agents.get_version(
        agent_name=AGENT_NAME, agent_version=created.version
    )
    status = version["status"]
    print(f"Status: {status}")
    if status == "active":
        break
    if status == "failed":
        raise RuntimeError(f"Provisioning failed: {version.get('error')}")
    time.sleep(5)

Consulte Sondear si está activo para consultar la lista completa de valores de estado y cómo leer el objeto error en caso de error.

Invoque al agente

Una vez que la versión alcanza active, enlace un cliente de OpenAI al punto de conexión del agente y llámelo. En este ejemplo se usa el protocolo Responses:

openai_client = project.get_openai_client(agent_name=AGENT_NAME)

response = openai_client.responses.create(input="Hello! What can you do?")
print(response.output_text)

Para el protocolo Invocations, llame directamente al punto de conexión invoke con un token de portador, como se muestra en Invocar al agente.

Descargar el archivo ZIP desplegado

Compruebe exactamente lo que se implementa descargando el archivo ZIP y comparando su SHA-256 con el valor que cargó:

import hashlib
from pathlib import Path

out_path = Path(f"{AGENT_NAME}-{created.version}.zip")
sha = hashlib.sha256()
with open(out_path, "wb") as f:
    for chunk in project.agents.download_code(
        agent_name=AGENT_NAME, agent_version=created.version
    ):
        f.write(chunk)
        sha.update(chunk)

print(f"Downloaded {out_path} (matches upload: {sha.hexdigest() == code_zip_sha256})")

Para obtener un ejemplo completo de ejecución, consulte los ejemplos de Python hosted-agent.

Use el SDK de .NET para implementar agentes de código fuente desde sus propias aplicaciones o automatización. A diferencia de los métodos de Python y REST, el SDK de .NET se encarga de comprimir una carpeta de origen por usted: se le pasa la ruta de una carpeta en lugar de tener que crear usted mismo el archivo ZIP.

Creación del agente

using System;
using Azure.AI.Projects.Agents;
using Azure.Identity;

// Format: "https://<account>.services.ai.azure.com/api/projects/<project>"
string projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT");

var agentsClient = new AgentAdministrationClient(
    endpoint: new Uri(projectEndpoint),
    tokenProvider: new DefaultAzureCredential());

var agentDefinition = new HostedAgentDefinition(cpu: "1", memory: "2Gi")
{
    Versions = { new ProtocolVersionRecord(ProjectsAgentProtocol.Responses, "1.0.0") },
    CodeConfiguration = new(
        runtime: "dotnet_10",
        entryPoint: ["dotnet", "MyAgent.dll"],
        dependencyResolution: CodeDependencyResolution.RemoteBuild),
};

var metadata = new AgentVersionFromCodeMetadata(agentDefinition);

ProjectsAgentVersion agentVersion = agentsClient.CreateAgentVersionFromCode(
    agentName: "my-code-agent",
    filePath: "./AgentCode",
    metadata: metadata);

Console.WriteLine($"Created version: {agentVersion.Version}");

Con remote_build, dirija filePath a una carpeta con el código fuente de un proyecto de .NET. El servicio Agente ejecuta dotnet restore y dotnet publish en su nombre durante el aprovisionamiento. entryPoint hace referencia al nombre del ensamblado publicado, por ejemplo, ["dotnet", "MyAgent.dll"] para un proyecto denominado MyAgent.csproj.

Para el protocolo Invocaciones, cambie la Versions entrada a new ProtocolVersionRecord(ProjectsAgentProtocol.Invocations, "1.0.0"). Para el protocolo Invocations (WebSocket), utilice new ProtocolVersionRecord(ProjectsAgentProtocol.InvocationsWs, "1.0.0"). Para el modo bundled, establezca dependencyResolution: CodeDependencyResolution.Bundled y apunte filePath a una carpeta que contiene la salida de dotnet publish. Consulte Compilar salida de .NET (incluida en paquete).

Sondear por activo

while (agentVersion.Status != AgentVersionStatus.Active &&
       agentVersion.Status != AgentVersionStatus.Failed)
{
    Thread.Sleep(500);
    agentVersion = agentsClient.GetAgentVersion(
        agentName: agentVersion.Name,
        agentVersion: agentVersion.Version);
}

if (agentVersion.Status != AgentVersionStatus.Active)
{
    throw new InvalidOperationException($"Deployment failed, status: {agentVersion.Status}");
}

Descarga del código implementado

Descargue y extraiga el código implementado en un directorio local para comprobar lo que se está ejecutando. El SDK escribe el contenido descomprimido en path:

agentsClient.DownloadAgentCode(agentName: agentVersion.Name, path: "./downloaded");
Console.WriteLine("Downloaded agent code to ./downloaded");

Para obtener un ejemplo completo de ejecución, consulte los ejemplos de .NET hosted-agent.

Use el SDK de JavaScript/TypeScript para implementar agentes de código fuente desde sus propias aplicaciones o automatización. El llamador del SDK se ejecuta en Node.js, pero el entorno de ejecución hospedado que implementa puede ser Python o .NET código fuente, no hay ningún entorno de ejecución del agente hospedado Node.js. Compile el archivo ZIP y pase sus bytes y SHA-256 al SDK, que lo carga y expone las mismas operaciones de creación, sondeo, invocación y descarga que la API REST.

Compilación del archivo ZIP

El SDK de JavaScript/TypeScript sube un archivo ZIP que creas. Use las mismas reglas de diseño y resolución de dependencias descritas en Empaquetar el archivo ZIP manualmente. La carga mínima remote_build de un entorno de ejecución de Python es un zip plano con main.py y requirements.txt en la raíz.

Creación del agente

npm install @azure/ai-projects @azure/identity

import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";
import { AIProjectClient } from "@azure/ai-projects";
import { DefaultAzureCredential } from "@azure/identity";

// Format: "https://<account>.services.ai.azure.com/api/projects/<project>"
const projectEndpoint =
  process.env["FOUNDRY_PROJECT_ENDPOINT"] || "your_project_endpoint";
const agentName = "my-code-agent";

const codeZip = readFileSync("agent-code.zip");
const codeZipSha256 = createHash("sha256").update(codeZip).digest("hex");

const project = new AIProjectClient(
  projectEndpoint,
  new DefaultAzureCredential(),
);

// The hosted runtime is Python here; the caller SDK is
// JavaScript/TypeScript. To deploy .NET source instead, set
// runtime to "dotnet_10" and entry_point to ["dotnet", "MyAgent.dll"].
const created = await project.agents.createVersionFromCode(
  agentName,
  codeZipSha256,
  {
    metadata: {
      description: "Hello-world code agent",
      definition: {
        kind: "hosted",
        cpu: "1",
        memory: "2Gi",
        code_configuration: {
          runtime: "python_3_13",
          entry_point: ["python", "main.py"],
          dependency_resolution: "remote_build",
        },
        protocol_versions: [{ protocol: "responses", version: "1.0.0" }],
        environment_variables: {
          AZURE_AI_MODEL_DEPLOYMENT_NAME: "gpt-5.4-mini",
        },
      },
    },
    code: {
      contents: codeZip,
      contentType: "application/zip",
      filename: "agent-code.zip",
    },
  },
);
console.log(`Created version: ${created.version}`);

Para el protocolo Invocations, establezca la entrada protocol_versions en { protocol: "invocations", version: "1.0.0" }. Para el protocolo Invocations (WebSocket), utilice { protocol: "invocations_ws", version: "1.0.0" }. Para el modo bundled, establezca dependency_resolution: "bundled" e incluya dependencias precompiladas en el zip.

Sondear por activo

function sleep(ms: number) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

for (;;) {
  await sleep(5_000);
  const version = await project.agents.getVersion(
    agentName,
    created.version,
  );
  console.log(`Status: ${version.status}`);
  if (version.status === "active") {
    break;
  }
  if (version.status === "failed") {
    throw new Error(`Provisioning failed: ${JSON.stringify(version)}`);
  }
}

Consulte Sondear si está activo para consultar la lista completa de valores de estado y cómo leer el objeto error en caso de error.

Invoque al agente

Una vez que la versión alcanza active, enlace un cliente de OpenAI al punto de conexión del agente y llámelo. En este ejemplo se usa el protocolo Responses:

const openAIClient = project.getOpenAIClient({
  azureConfig: { allowPreview: true, agentName },
});

const response = await openAIClient.responses.create({
  input: "Hello! What can you do?",
});
console.log(response.output_text);

Para el protocolo Invocations, llame directamente al punto de conexión invoke con un token de portador, como se muestra en Invocar al agente.

Descargar el archivo ZIP desplegado

Compruebe lo que se implementa descargando el archivo ZIP y comparando su valor SHA-256 con el valor que cargó:

import { createHash } from "node:crypto";
import { writeFileSync } from "node:fs";
import { buffer } from "node:stream/consumers";

const downloadResult = await project.agents.downloadAgentCode(agentName, {
  agentVersion: created.version,
});

// The result carries either a Node.js stream (readableStreamBody) or a
// browser Blob (blobBody), depending on the runtime. Handle both so the
// code compiles under strict TypeScript and works in either environment.
const downloadedBytes = downloadResult.readableStreamBody
  ? new Uint8Array(await buffer(downloadResult.readableStreamBody))
  : downloadResult.blobBody
    ? new Uint8Array(await (await downloadResult.blobBody).arrayBuffer())
    : undefined;

if (!downloadedBytes) {
  throw new Error("No content found in the downloaded agent code.");
}

const downloadedSha256 = createHash("sha256")
  .update(downloadedBytes)
  .digest("hex");

writeFileSync(`${agentName}-${created.version}.zip`, downloadedBytes);
console.log(
  `Downloaded (matches upload: ${downloadedSha256 === codeZipSha256})`,
);

Referencia: AIProjectClient

Puede usar la API REST para implementaciones directas basadas en HTTP o herramientas personalizadas. Las secciones le guiarán por una primera implementación en orden: configurar variables, compilar un archivo ZIP, crear el agente, sondear hasta activee invocarlo. Los puntos de conexión de actualización, versión, descarga y streaming de registros se agrupan en operaciones en curso.

Implementación mediante la API REST

Use la API REST para implementaciones directas basadas en HTTP o herramientas personalizadas. Las secciones siguientes le guían por una primera implementación en orden: configurar variables, crear un archivo ZIP, crear el agente, sondear hasta activee invocarlo. Los puntos de conexión de actualización, versión, descarga y streaming de registros se agrupan en operaciones en curso.

Configurar variables

Bash

ENDPOINT="https://{account}.services.ai.azure.com/api/projects/{project}"
API_VERSION="v1"
TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)
AGENT=my-code-agent
AGENT_VERSION=1
ZIP=./agent-code.zip
SHA=$(sha256sum "$ZIP" | cut -d' ' -f1)

PowerShell

$Endpoint    = "https://{account}.services.ai.azure.com/api/projects/{project}"
$ApiVersion  = "v1"
$Token       = az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv
$Agent       = "my-code-agent"
$Zip         = "./agent-code.zip"
$Sha         = (Get-FileHash $Zip -Algorithm SHA256).Hash.ToLower()

Crea un archivo zip mínimo de hello-world

Antes de llamar a Create, cree un archivo ZIP plano con dos archivos. Este es el contenido mínimo que acepta Agent Service para un despliegue de Python remote_build.

agent-code.zip
+-- main.py            # your agent loop (starts a Foundry hosting server)
+-- requirements.txt   # dependencies (for example, agent-framework, agent-framework-foundry-hosting)

metadata.json (la definición del agente que se muestra en el ejemplo de metadatos) se encuentra junto al archivo ZIP en el disco y se envía como una parte de varias partes independiente; no está dentro del archivo ZIP. Para ver las estructuras completas (incluidos el modo bundled y .NET), consulte Empaquetar el archivo zip manualmente. Para ver los archivos de origen de trabajo, consulte los ejemplos Python y .NET.

Estructura de la solicitud multiparte

Todos los endpoints de modificación (Create, Update) usan multipart/form-data y constan de dos partes:

Encabezados necesarios en cada llamada de varias partes:

Authorization: Bearer <token>
Accept: application/json
x-ms-code-zip-sha256: <sha256-hex-of-zip>

El x-ms-code-zip-sha256 encabezado registra el SHA-256 del archivo ZIP que cargó. El servicio lo almacena y lo devuelve en code:download para que puedas detectar las diferencias entre lo que esperabas desplegar y lo que está desplegado. Inclúyalo siempre.

La llamada Create también requiere x-ms-agent-name: <agent-name>. Las llamadas de actualización lo omiten porque el nombre ya forma parte de la dirección URL.

Ejemplo de metadatos (compilación remota, respuestas)

Estos metadatos coinciden con el archivo ZIP hello-world.

{
  "description": "Hello-world code agent",
  "definition": {
    "kind": "hosted",
    "protocol_versions": [
      { "protocol": "responses", "version": "1.0.0" }
    ],
    "cpu": "1",
    "memory": "2Gi",
    "code_configuration": {
      "runtime": "python_3_13",
      "entry_point": ["python", "main.py"],
      "dependency_resolution": "remote_build"
    },
    "environment_variables": {
      "AZURE_AI_MODEL_DEPLOYMENT_NAME": "gpt-5.4-mini"
    }
  }
}

Para el protocolo Invocaciones, reemplace la protocol_versions entrada por { "protocol": "invocations", "version": "1.0.0" }. Para el protocolo Invocations (WebSocket), utilice { "protocol": "invocations_ws", "version": "1.0.0" }. Para el modo bundled, configure "dependency_resolution": "bundled" y siga Compilar las dependencias de Linux localmente.

code_configuration y container_configuration son mutuamente excluyentes en la definición del agente: incluya code_configuration para la implementación de código fuente (este artículo) o container_configuration para la implementación basada en imágenes. Consulte Implementación de un agente hospedado (contenedor) para la variante de imagen.

Creación del agente

curl -X POST "$ENDPOINT/agents?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json" \
  -H "x-ms-agent-name: $AGENT" \
  -H "x-ms-code-zip-sha256: $SHA" \
  -F "metadata=@metadata.json;type=application/json" \
  -F "code=@$ZIP;type=application/zip;filename=$AGENT.zip"

x-ms-agent-name solo se requiere en la llamada Create. El nombre debe comenzar y terminar con caracteres alfanuméricos, puede contener guiones en medio y no debe superar los 63 caracteres. La respuesta incluye un status inicial de creating.

Sondear por activo

while true; do
  STATUS=$(curl -s -H "Authorization: Bearer $TOKEN" \
    "$ENDPOINT/agents/$AGENT/versions/$AGENT_VERSION?api-version=$API_VERSION" | jq -r '.status')
  echo "Status: $STATUS"
  [ "$STATUS" = "active" ] && break
  [ "$STATUS" = "failed" ] && echo "Provisioning failed." && exit 1
  sleep 5
done

Invoque al agente

Elija el protocolo que el agente declaró en protocol_versions.

Protocolo de respuestas:

curl -X POST "$ENDPOINT/agents/$AGENT/endpoint/protocols/openai/responses?api-version=v1" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-5.4-mini","input":"Hello, agent!","stream":false}'

Protocolo de invocaciones:

curl -X POST "$ENDPOINT/agents/$AGENT/endpoint/protocols/invocations?api-version=v1" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"input":"Hello, this is a test invocation!"}'

Protocolo invocaciones (WebSocket):

Conéctese a través de una actualización de WebSocket en lugar de un REST POST. Para consultar el formato del endpoint y ejemplos de cliente, consulte Crear un agente de voz con agentes alojados.

Encabezados de respuesta útiles:

Para el protocolo Responses, el identificador de respuesta de cada llamada es el campo id en el cuerpo de la respuesta JSON (por ejemplo, caresp_<random>). Úselo para correlacionar la llamada con registros de contenedor o para hacer referencia a la llamada en una solicitud de soporte técnico.

Operaciones en curso

Después de la primera implementación, use estos puntos de conexión para evolucionar y operar el agente.

Actualización o versión de un agente

Para implementar un cambio de código o una actualización de definición, vuelva a enviar el cuerpo multiparte al recurso del agente. El servicio usa versionado direccionable por contenido: solo se genera una nueva versión cuando el SHA-256 del archivo zip o la definición del agente cambian realmente. Los repostes idénticos devuelven la versión más reciente existente.

curl -X POST "$ENDPOINT/agents/$AGENT?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "x-ms-code-zip-sha256: $SHA" \
  -F "metadata=@metadata.json;type=application/json" \
  -F "code=@$ZIP;type=application/zip;filename=$AGENT.zip"

La respuesta es el sobre del agente completo con versions.latest rellenado. Sondee la versión resultante como se muestra en Sondear para activar.

Si sus herramientas prefieren una respuesta con formato de versión (un AgentVersionObject simple en lugar del contenedor del agente), publique el mismo cuerpo multiparte en $ENDPOINT/agents/$AGENT/versions?api-version=$API_VERSION. La regla de deduplicación es idéntica: ambos extremos comparten la misma lógica de direccionamiento por contenido.

Descargar el archivo ZIP desplegado

Compruebe exactamente lo que se implementa mediante la descarga del archivo ZIP. Omita agent_version para descargar la versión más reciente; pase agent_version=<n> para indicar una versión específica.

VERSION=1

# Latest version
curl -O -J "$ENDPOINT/agents/$AGENT/code:download?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/zip"

# Specific version
curl -O -J "$ENDPOINT/agents/$AGENT/code:download?api-version=$API_VERSION&agent_version=$VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/zip"

Dos encabezados de respuesta le ayudan a confirmar lo que descargó:

Los agentes basados en imágenes devuelven 409 AgentNotCodeBased.

Transmitir registros del contenedor

curl -N "$ENDPOINT/agents/$AGENT/sessions/<sessionId>:logstream?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: text/event-stream"

Los registros se entregan como eventos enviados por el servidor. {sessionId} es el valor de x-agent-session-id de la respuesta de invocación. Use este punto de conexión para depurar fallos en tiempo de ejecución y respuestas 424 session_not_ready.

diseño Python (modo de compilación remota)

El servicio instala dependencias en la nube desde requirements.txt.

agent-code.zip
+-- main.py
+-- requirements.txt

diseño Python (modo agrupado)

Las dependencias precompiladas de Linux se envían en packages/.

agent-code.zip
+-- main.py                    # entry point
+-- requirements.txt
+-- packages/                  # extracted modules (not raw .whl files)
    +-- azure/identity/__init__.py
    +-- requests/__init__.py

Compilación de dependencias de Linux localmente (agrupadas, Python)

Use la etiqueta de plataforma manylinux2014_x86_64 para que pip descargue paquetes wheels de Linux incluso desde Windows o macOS.

Bash

pip install -r requirements.txt \
    --target packages/ \
    --platform manylinux2014_x86_64 \
    --python-version 3.13 \
    --implementation cp \
    --only-binary=:all:

zip -r agent-code.zip main.py requirements.txt packages/

PowerShell/Windows cmd

pip install -r requirements.txt --target packages --platform manylinux2014_x86_64 --python-version 3.13 --implementation cp --only-binary=:all:

tar -a -c -f agent-code.zip main.py requirements.txt packages

--only-binary=:all: fuerza el uso de paquetes wheels (sin compilaciones desde el código fuente). --python-version debe coincidir con el runtime valor de la definición del agente.

diseño de .NET (modo de compilación remota)

Comprima solo las fuentes del proyecto; sin salida de bin/, obj/ ni publish/. El servicio Agente ejecuta dotnet restore y dotnet publish en su nombre durante el aprovisionamiento.

agent-code.zip
+-- MyAgent.csproj
+-- Program.cs
+-- ... (additional .cs files)

El entry_point que se establece en la definición del agente sigue haciendo referencia al nombre del ensamblado publicado (por ejemplo, ["dotnet", "MyAgent.dll"]), generado por la publicación del lado servidor.

estructura de .NET (modo agrupado)

Comprima la salida de dotnet publish -c Release -r linux-x64 --self-contained false directamente en la raíz del archivo ZIP:

agent-code.zip
+-- MyAgent.dll
+-- MyAgent.runtimeconfig.json
+-- ... (publish output)

Generar .NET salida (agrupada)

dotnet publish -c Release -r linux-x64 --self-contained false -o publish/
cd publish && zip -r ../agent-code.zip .

Use --self-contained true si desea enviar el entorno de ejecución de .NET en el archivo ZIP. El runtime que establezca en la definición del agente debe coincidir con .TargetFramework

El SDK de JavaScript/TypeScript carga paquetes fuente de Python o de .NET. No hay un entorno de ejecución hospedado Node.js. Compile el archivo ZIP siguiendo la pestaña Python o C# del entorno de ejecución que implemente y cárguelo con project.agents.createVersionFromCode().

Consulte las pestañas Python o C#.

# Delete one version
project.agents.delete_version(agent_name=AGENT_NAME, agent_version=created.version)

# Delete the agent and all its versions
project.agents.delete(agent_name=AGENT_NAME)

// Delete the agent and all its versions (force cascades to active sessions)
agentsClient.DeleteAgent(agentName: "my-code-agent", force: true);

// Delete one version
await project.agents.deleteVersion(agentName, created.version);

// Delete the agent and all its versions (force cascades to active sessions)
await project.agents.delete(agentName, { force: true });

Referencia: AIProjectClient

# Delete one version
curl -X DELETE "$ENDPOINT/agents/$AGENT/versions/$AGENT_VERSION?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN"

# Delete the agent and all its versions
curl -X DELETE "$ENDPOINT/agents/$AGENT?api-version=$API_VERSION" \
  -H "Authorization: Bearer $TOKEN"

# Force-delete the agent (cascades to any active sessions)
curl -X DELETE "$ENDPOINT/agents/$AGENT?api-version=$API_VERSION&force=true" \
  -H "Authorization: Bearer $TOKEN"