Een gehoste agent implementeren vanuit broncode

• pip van Python 3.13 of hoger om uw bron lokaal te verpakken.

• De azure-ai-projects versie 2.2.0 of hoger en azure-identity pakketten.

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

• De .NET 10 SDK om uw bron lokaal te verpakken.

• De pakketten Azure.AI.Projects.Agents en Azure.Identity.

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

  Note

  De API's voor broncode-implementatie voor .NET zijn momenteel alleen beschikbaar in een voorlopige versie van Azure.AI.Projects.Agents. Gebruik de --prerelease vlag om deze te installeren. Deze API's zijn nog niet opgenomen in de stabiele release (GA).

• Node.js 22 of hoger om uw bron lokaal te verpakken.

• De pakketten @azure/ai-projects en @azure/identity. U voert de aanroeper uit in Node.js, maar de gehoste runtime die u implementeert, is nog steeds Python of .NET broncode.

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

• Een opdrachtregel-HTTP-client zoals curl (de REST-voorbeelden in dit artikel gebruiken curl).
• Als u de bron lokaal wilt verpakken, installeert u de hulpprogrammaketen voor de taal van uw agent: pip van Python 3.13 of hoger, of de .NET 10 SDK.

Gebruik de Python SDK om broncodeagents te implementeren vanuit uw eigen toepassingen of automatisering. U bouwt de zip zelf en geeft de bytes en SHA-256 door aan de SDK, die deze uploadt en dezelfde bewerkingen voor maken, peilen, aanroepen en downloaden beschikbaar maakt als de REST API. Voor code-implementatie is versie 2.2.0 of hoger vereist azure-ai-projects .

De zip bouwen

De Python SDK uploadt een zip-bestand dat u bouwt. Gebruik dezelfde regels voor lay-out en afhankelijkheidsoplossing die worden beschreven in Het zip-bestand handmatig verpakken. Het minimale remote_build pakket is een platte zip met main.py en requirements.txt in de hoofdmap.

De agent maken

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}")

Stel voor het protocol Aanroepen de protocol_versions vermelding in op ProtocolVersionRecord(protocol="invocations", version="1.0.0"). Gebruik ProtocolVersionRecord(protocol="invocations_ws", version="1.0.0") voor het protocol Invocations (WebSocket). Voor modus bundled, stelt u dependency_resolution="bundled" in en levert u vooraf gebouwde afhankelijkheden mee in het zipbestand. Zie Linux-afhankelijkheden lokaal bouwen voor meer informatie.

Poll voor actief

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)

Zie Poll for active voor de volledige lijst met statuswaarden en hoe u het object error kunt uitlezen bij een fout.

De agent aanroepen

Nadat de versie active heeft bereikt, koppelt u een OpenAI-client aan het agent-eindpunt en roept u het aan. In dit voorbeeld wordt het protocol Antwoorden gebruikt:

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)

Voor het Invocations-protocol roept u het invoke-eindpunt rechtstreeks aan met een bearertoken, zoals getoond in De agent aanroepen.

De geïmplementeerde zip downloaden

Controleer precies wat er is geïmplementeerd door het zip-bestand te downloaden en de SHA-256 te vergelijken met de waarde die u hebt geüpload:

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})")

Zie de Python voorbeelden van gehoste agents voor een volledig voorbeeld dat kan worden uitgevoerd.

Gebruik de .NET SDK om broncodeagents te implementeren vanuit uw eigen toepassingen of automatisering. In tegenstelling tot de Python- en REST-paden, wordt met de .NET SDK een bronmap voor u gezipt. U geeft een mappad door in plaats van de zip zelf te bouwen.

De agent maken

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}");

Wijs met remote_buildfilePath een map met .NET projectbronnen aan. Agent Service voert dotnet restore en dotnet publish voor u uit tijdens de inrichting. De entryPoint naam verwijst naar de naam van de gepubliceerde assembly, bijvoorbeeld ["dotnet", "MyAgent.dll"] voor een project met de naam MyAgent.csproj.

Voor het protocol Aanroepen wijzigt u de Versions vermelding in new ProtocolVersionRecord(ProjectsAgentProtocol.Invocations, "1.0.0"). Gebruik new ProtocolVersionRecord(ProjectsAgentProtocol.InvocationsWs, "1.0.0") voor het protocol Invocations (WebSocket). Voor de modus bundled, stel dependencyResolution: CodeDependencyResolution.Bundled in en laat filePath verwijzen naar een map die uw dotnet publish-uitvoer bevat. Zie .NET-uitvoer bouwen (gebundeld).

Poll voor actief

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}");
}

De geïmplementeerde code downloaden

Download en pak de geïmplementeerde code uit in een lokale map om te controleren wat er wordt uitgevoerd. De SDK schrijft de uitgepakte inhoud naar path:

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

Zie de .NET voorbeelden van gehoste agents voor een volledig voorbeeld dat kan worden uitgevoerd.

Gebruik de JavaScript/TypeScript SDK om broncodeagents te implementeren vanuit uw eigen toepassingen of automatisering. De SDK-aanroeper wordt uitgevoerd in Node.js, maar de gehoste runtime die wordt geïmplementeerd, kan Python of .NET broncode zijn. Er is geen Node.js Runtime gehoste agent. U bouwt de zip zelf en geeft de bytes en SHA-256 door aan de SDK, die deze uploadt en dezelfde bewerkingen voor maken, peilen, aanroepen en downloaden beschikbaar maakt als de REST API.

De zip bouwen

De JavaScript/TypeScript SDK uploadt een zip-bestand dat u bouwt. Gebruik dezelfde regels voor lay-out en afhankelijkheidsoplossing die worden beschreven in Het zip-bestand handmatig verpakken. De minimale remote_build payload voor een Python-runtime is een plat zipbestand met main.py en requirements.txt in de root.

De agent maken

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}`);

Stel voor het protocol Aanroepen de protocol_versions vermelding in op { protocol: "invocations", version: "1.0.0" }. Gebruik { protocol: "invocations_ws", version: "1.0.0" } voor het protocol Invocations (WebSocket). Voor de modus bundled stelt u dependency_resolution: "bundled" in en voegt u vooraf gebouwde afhankelijkheden toe aan het zip-bestand.

Poll voor actief

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)}`);
  }
}

Zie Poll for active voor de volledige lijst met statuswaarden en hoe u het object error kunt uitlezen bij een fout.

De agent aanroepen

Nadat de versie active heeft bereikt, koppelt u een OpenAI-client aan het agent-eindpunt en roept u het aan. In dit voorbeeld wordt het protocol Antwoorden gebruikt:

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);

Voor het Invocations-protocol roept u het invoke-eindpunt rechtstreeks aan met een bearertoken, zoals getoond in De agent aanroepen.

De geïmplementeerde zip downloaden

Controleer wat er is geïmplementeerd door het zip-bestand te downloaden en de SHA-256-waarde te vergelijken met de waarde die u hebt geüpload:

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})`,
);

Referentie: AIProjectClient

U kunt de REST API gebruiken voor directe HTTP-implementaties of aangepaste hulpprogramma's. De secties leiden je stap voor stap door een eerste uitrol, in deze volgorde: variabelen instellen, een zipbestand maken, de agent aanmaken, controleren totdat active, en deze aanroepen. Update-, versie-, download- en logboekstreaming-eindpunten worden gegroepeerd onder Doorlopende bewerkingen.

Implementeren met behulp van de REST API

Gebruik de REST API voor directe HTTP-implementaties of aangepaste hulpprogramma's. In de onderstaande secties doorloopt u een eerste uitrol in deze volgorde: variabelen instellen, een zipbestand maken, de agent aanmaken, polling uitvoeren totdat active, en deze aanroepen. Update-, versie-, download- en logboekstreaming-eindpunten worden gegroepeerd onder Doorlopende bewerkingen.

Variabelen instellen

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()

Een minimale hello-world zip bouwen

Voordat u Create aanroept, bouwt u een platte zip met twee bestanden. Dit is de minimale payload die Agent Service accepteert voor een Python remote_build-implementatie.

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 (de agentdefinitie die wordt weergegeven in het voorbeeld van metagegevens) bevindt zich naast het zip-bestand op de schijf en wordt verzonden als een afzonderlijk onderdeel. De definitie bevindt zich niet in de zip. Zie bundled voor volledige indelingen (inclusief modus en .NET). Zie de voorbeelden Python en .NET voor werkbronbestanden.

Vorm van een meerdelige aanvraag

Alle eindpunten die gegevens wijzigen (Create, Update) gebruiken multipart/form-data, die uit twee delen bestaat:

Vereiste headers voor elke aanroep met meerdere onderdelen:

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

De x-ms-code-zip-sha256 header registreert de SHA-256 van de zip die u hebt geüpload. De service slaat deze op en echot deze weer aan code:download , zodat u afwijkingen kunt detecteren tussen wat u verwachtte te implementeren en wat er is geïmplementeerd. Voeg het altijd toe.

De Create-aanroep vereist ook x-ms-agent-name: <agent-name>. Bijwerkoproepen laten deze weg omdat de naam al deel uitmaakt van de URL.

Voorbeeld van metagegevens (externe build, antwoorden)

Deze metagegevens komen overeen met de hello-world zip.

{
  "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"
    }
  }
}

Vervang in het protocol Aanroepen de protocol_versions-vermelding door { "protocol": "invocations", "version": "1.0.0" }. Gebruik { "protocol": "invocations_ws", "version": "1.0.0" } voor het protocol Invocations (WebSocket). Voor de modus bundled stelt u "dependency_resolution": "bundled" in en volgt u Linux-afhankelijkheden lokaal bouwen.

code_configuration en container_configuration sluiten elkaar uit in de agentdefinitie: gebruik code_configuration voor implementatie van broncode (dit artikel) of container_configuration voor deploy op basis van images. Zie Een gehoste agent (container) implementeren voor de installatiekopievariant.

De agent maken

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 is alleen vereist bij de Create-aanroep. De naam moet beginnen en eindigen met alfanumerieke tekens, kan afbreekstreepjes in het midden bevatten en mag niet langer zijn dan 63 tekens. Het antwoord bevat een initiële status van creating.

Poll voor actief

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

De agent aanroepen

Kies het protocol dat uw agent heeft gedeclareerd in protocol_versions.

Antwoordprotocol:

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}'

Protocol voor aanroepen:

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!"}'

Protocol voor aanroepen (WebSocket):

Verbinding maken via een WebSocket-upgrade in plaats van een REST POST. Zie Een spraakagent bouwen met gehoste agents voor de eindpuntindeling en clientvoorbeelden.

Nuttige antwoordheaders:

Voor het protocol Antwoorden is de antwoord-id per aanroep het id veld in de hoofdtekst van de antwoord-JSON (bijvoorbeeld caresp_<random>). Gebruik deze om de oproep te correleren met containerlogboeken of om te verwijzen naar de oproep in een ondersteuningsaanvraag.

Lopende bewerkingen

Nadat u de eerste implementatie hebt uitgevoerd, gebruikt u deze eindpunten om de agent te ontwikkelen en te gebruiken.

Een agent bijwerken of versien

Als u een codewijziging of definitie-update wilt implementeren, moet u de hoofdtekst van meerdere onderdelen opnieuw posten in de agentresource. De service maakt gebruik van versiebeheer van inhoudsadressen: een nieuwe versie wordt alleen gebruikt wanneer de SHA-256 van de zip of de agentdefinitie daadwerkelijk wordt gewijzigd. Identieke herplaatsingen geven de bestaande meest recente versie terug.

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"

Het antwoord is de volledige agent-envelope met versions.latest ingevuld. Controleer de resulterende versie, zoals weergegeven in Poll for active.

Als uw tooling de voorkeur geeft aan een versievormig antwoord (een lege AgentVersionObject in plaats van de agentenvelop), plaatst u dezelfde hoofdtekst met meerdere onderdelen op $ENDPOINT/agents/$AGENT/versions?api-version=$API_VERSION. De ontdubbelingsregel is identiek: beide eindpunten delen dezelfde logica voor inhoudsadressen.

De geïmplementeerde zip downloaden

Controleer precies wat er is geïmplementeerd door het zip-bestand te downloaden. Laat agent_version weg om de nieuwste versie te downloaden; geef agent_version=<n> mee om een specifieke versie op te geven.

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"

Met twee antwoordheaders kunt u bevestigen wat u hebt gedownload:

Op afbeeldingen gebaseerde agents geven 409 AgentNotCodeBased terug.

Containerlogboeken streamen

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

Logboeken worden geleverd als gebeurtenissen die door de server worden verzonden. {sessionId} is de waarde van x-agent-session-id uit het antwoord van de aanroep. Gebruik dit eindpunt om fouten en 424 session_not_ready reacties in runtime op te sporen.

Python-opmaak (buildmodus op afstand)

De service installeert afhankelijkheden in de cloud van requirements.txt.

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

Python-lay-out (gebundelde modus)

U verzendt vooraf gemaakte Linux-afhankelijkheden in packages/.

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

Lokale Linux-afhankelijkheden bouwen (gebundeld, Python)

Gebruik de manylinux2014_x86_64 platformtag, zodat pip Linux-wielen downloadt, zelfs vanuit Windows of 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: dwingt wielen (geen bron builds). De --python-version waarde moet overeenkomen met de runtime waarde in de agentdefinitie.

.NET-lay-out (modus voor extern bouwen)

Zip de projectbronnen alleen ( geen bin/, obj/of publish/ uitvoer). Agent Service voert dotnet restore en dotnet publish voor u uit tijdens de inrichting.

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

De entry_point die u in de agentdefinitie hebt ingesteld, verwijst nog steeds naar de gepubliceerde assemblynaam (bijvoorbeeld ["dotnet", "MyAgent.dll"]), die door de publicatie aan de serverzijde wordt gegenereerd.

.NET-lay-out (gebundelde uitvoering)

Zip de uitvoer van dotnet publish -c Release -r linux-x64 --self-contained false geroot rechtstreeks in de zip:

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

Compileer .NET-uitvoer (gebundeld)

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

Gebruik --self-contained true als u de .NET runtime in de zip wilt verzenden. De runtime die je in de agentdefinitie instelt, moet overeenkomen met de TargetFramework.

De JavaScript/TypeScript SDK uploadt Python of .NET bronpakketten. Er is geen Node.js gehoste runtime. Bouw het zip-bestand door het tabblad Python of C# te volgen voor de runtime die u implementeert en upload het vervolgens met project.agents.createVersionFromCode().

Bekijk de tabbladen Python of 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 });

Referentie: 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"