Agent-Beobachtbarkeit

Installieren Sie die Kern-, Überwachbarkeits- und Laufzeitpakete. Alle Agents, die Agent 365 Observability verwenden, benötigen diese Pakete.

pip install microsoft-agents-a365-observability-core
pip install microsoft-agents-a365-runtime

Wenn Ihr Agent das Hostingpaket Microsoft Agents Hosting verwendet, installieren Sie das Hostingintegrationspaket. Es stellt Middleware bereit, die automatisch Baggage und Scopes von TurnContext übernimmt, einschließlich der Token-Zwischenspeicherung für den Observability-Exporter.

pip install microsoft-agents-a365-observability-hosting

Wenn Ihr Agent eines der unterstützten KI-Frameworks verwendet, installieren Sie die entsprechende Erweiterung für die automatische Instrumentierung, um Telemetrie automatisch ohne manuellen Instrumentierungscode zu erfassen. Konfigurationsdetails finden Sie unter "Automatische Instrumentierung".

# For Semantic Kernel
pip install microsoft-agents-a365-observability-extensions-semantic-kernel

# For OpenAI Agents SDK
pip install microsoft-agents-a365-observability-extensions-openai

# For Microsoft Agent Framework
pip install microsoft-agents-a365-observability-extensions-agent-framework

# For LangChain
pip install microsoft-agents-a365-observability-extensions-langchain

Installieren Sie die Kern-, Überwachbarkeits- und Laufzeitpakete. Alle Agents, die Agent 365 Observability verwenden, benötigen diese Pakete.

npm install @microsoft/agents-a365-observability
npm install @microsoft/agents-a365-runtime

Wenn Ihr Agent das @microsoft/agents-hosting-Paket verwendet, installieren Sie das Hostingintegrationspaket. Es stellt Middleware bereit, die automatisch Baggage und Scopes von TurnContext übernimmt, einschließlich der Token-Zwischenspeicherung für den Observability-Exporter.

npm install @microsoft/agents-a365-observability-hosting

Wenn Ihr Agent eines der unterstützten KI-Frameworks verwendet, installieren Sie die entsprechende Erweiterung für die automatische Instrumentierung, um Telemetrie automatisch ohne manuellen Instrumentierungscode zu erfassen. Konfigurationsdetails finden Sie unter "Automatische Instrumentierung".

// For OpenAI Agents SDK
npm install @microsoft/agents-a365-observability-extensions-openai

// For LangChain
npm install @microsoft/agents-a365-observability-extensions-langchain

Installieren Sie das Beobachtbarkeits- und Laufzeit-Kernpaket. Alle Agents, die Agent 365 Observability verwenden, benötigen dieses Paket.

dotnet add package Microsoft.Agents.A365.Observability.Runtime

Wenn Ihr Agent das NuGet-Paket Microsoft.Agents.A365.Observability.Hosting verwendet, installieren Sie das Hosting-Integrationspaket. Es stellt Middleware bereit, die das Gepäck automatisch aus dem TurnContext auffüllt und die Tokenzwischenspeicherung für den Observability-Exporter umfasst.

dotnet add package Microsoft.Agents.A365.Observability.Hosting

Wenn Ihr Agent eines der unterstützten KI-Frameworks verwendet, installieren Sie die entsprechende Erweiterung für die automatische Instrumentierung, um Telemetrie automatisch ohne manuellen Instrumentierungscode zu erfassen. Konfigurationsdetails finden Sie unter "Automatische Instrumentierung".

// For Semantic Kernel
dotnet add package Microsoft.Agents.A365.Observability.Extensions.SemanticKernel

// For OpenAI
dotnet add package Microsoft.Agents.A365.Observability.Extensions.OpenAI

// For Agent Framework
dotnet add package Microsoft.Agents.A365.Observability.Extensions.AgentFramework

Setze die ENABLE_A365_OBSERVABILITY_EXPORTER Umgebungsvariable auf true für Beobachtbarkeit. Diese Einstellung exportiert Protokolle in den Dienst und setzt voraus, dass token_resolver bereitgestellt wird. Ansonsten wird der Konsolen-Exporter verwendet.

from microsoft_agents_a365.observability.core import configure

def token_resolver(agent_id: str, tenant_id: str) -> str | None:
    # Implement secure token retrieval here
    return "Bearer <token>"

configure(
    service_name="my-agent-service",
    service_namespace="my.namespace",
    token_resolver=token_resolver,
)

Die Tokenlöserfunktion ist von der Protokollierung in der Konsole ausgeschlossen.

Sie können das Exporterverhalten anpassen, indem Sie eine Agent365ExporterOptions Instanz an exporter_options. Wenn exporter_options bereitgestellt wird, hat es Vorrang vor den Parametern token_resolver und cluster_category.

from microsoft_agents_a365.observability.core import configure, Agent365ExporterOptions

configure(
    service_name="my-agent-service",
    service_namespace="my.namespace",
    exporter_options=Agent365ExporterOptions(
        cluster_category="prod",
        token_resolver=token_resolver,
    ),
    suppress_invoke_agent_input=True,
)

In der folgenden Tabelle werden die optionalen Parameter für configure() beschrieben.

Die folgende Tabelle beschreibt die optionalen Eigenschaften für Agent365ExporterOptions.

Setze die ENABLE_A365_OBSERVABILITY_EXPORTER Umgebungsvariable auf true für Beobachtbarkeit. Diese Einstellung exportiert Protokolle in den Dienst und erfordert einen Tokenlöser, der bereitgestellt werden muss. Ansonsten wird der Konsolen-Exporter verwendet.

import { ObservabilityManager } from '@microsoft/agents-a365-observability';

// Define a token resolver to authenticate with the observability service for exporting logs
const tokenResolver = (agentId, tenantId) => {
    // Your token resolution logic here
    return "your-token";
};

// Advanced configuration with builder pattern
const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withTokenResolver((agentId, tenantId) => {
      return tokenResolver(agentId, tenantId);
    })
);

builder.start();

Als Alternative zu Umgebungsvariablen können Sie die Beobachtbarkeit programmgesteuert mithilfe eines Konfigurationsanbieters über die withConfigurationProvider-Methode konfigurieren. Wenn Sie auch einzelne Generatormethoden (z. B. withExporterOptions oder withClusterCategory) verwenden, haben die einzelnen Generatormethoden Vorrang vor Werten des Konfigurationsanbieters.

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { ObservabilityConfiguration } from '@microsoft/agents-a365-observability';

const configProvider = new ObservabilityConfiguration({
  isObservabilityExporterEnabled: () => true,
  // Set log levels as pipe-separated values (for example, 'info|warn|error')
  observabilityLogLevel: () => 'info|warn|error',
});

const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withConfigurationProvider(configProvider)
    .withTokenResolver((agentId, tenantId) => {
      return tokenResolver(agentId, tenantId);
    })
);

builder.start();

Sie können das Exporterverhalten anpassen, indem Sie eine Agent365ExporterOptions Instanz an withExporterOptions. Mit dieser Option können Sie Batchverarbeitung, Timeouts und den Routenmodus steuern.

import {
  ObservabilityManager,
  Agent365ExporterOptions,
} from '@microsoft/agents-a365-observability';
import { ClusterCategory } from '@microsoft/agents-a365-runtime';

const exporterOptions = new Agent365ExporterOptions();
exporterOptions.maxQueueSize = 10;

const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withClusterCategory(ClusterCategory.prod)
    .withExporterOptions(exporterOptions)
    .withTokenResolver(tokenResolver)
);

builder.start();

Die folgende Tabelle beschreibt die optionalen Eigenschaften für Agent365ExporterOptions.

Du kannst auch einen benutzerdefinierten Logger bereitstellen, der die Schnittstelle ILogger implementiert (info, warn, error, event). Geben Sie es dem Konstrukteur weiter, indem Sie withCustomLogger verwenden.

const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withCustomLogger({
      info: (message, ...args) => { /* your logging logic */ },
      warn: (message, ...args) => { /* your logging logic */ },
      error: (message, ...args) => { /* your logging logic */ },
      event: (eventName, success, durationMs, message, details) => { /* your logging logic */ }
    })
    .withTokenResolver((agentId, tenantId) => {
      return tokenResolver(agentId, tenantId);
    })
);

builder.start();

Legen Sie EnableAgent365Exporter auf true in appsettings.json fest.

In Program.csAgent365ExporterOptions zur Dienstesammlung hinzufügen. Diese Änderung konfiguriert den Stellvertreter, den der Tracexporter zum Abrufen des Tokens verwendet.

Fügen Sie beobachtbarkeitsbezogene Abhängigkeiten hinzu, indem Sie verwenden AddA365Tracing().

using Microsoft.Agents.A365.Observability.Runtime;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Exporters;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton(sp =>
    {
        return new Agent365ExporterOptions
        {
            TokenResolver = async (agentId, tenantId) =>
            {
                // It's recommended to implement caching in your token provider for performance.
                var token = await tokenProvider.GetObservabilityTokenAsync(agentId, tenantId);
                return token;
            }
        };
    });

builder.AddA365Tracing();

Sie können das Exporterverhalten anpassen, indem Sie einen Konfigurations-Delegaten und einen Exporter-Typ an AddA365Tracing() übergeben.

builder.AddA365Tracing(
    configure: tracingBuilder =>
    {
        // Use the builder to add extensions (e.g., WithSemanticKernel(), WithOpenAI())
    },
    agent365ExporterType: Agent365ExporterType.Agent365ExporterAsync
);

Die folgende Tabelle beschreibt die optionalen Eigenschaften für Agent365ExporterOptions.

from microsoft_agents_a365.observability.core import BaggageBuilder

with (
    BaggageBuilder()
    .tenant_id("tenant-123")
    .agent_id("agent-456")
    .conversation_id("conv-789")
    .build()
):
    # Any spans started in this context will receive these as attributes
    pass

Verwenden Sie das populate-Hilfsprogramm im microsoft-agents-a365-observability-hosting-Paket, um das BaggageBuilder aus dem TurnContext automatisch auszufüllen. Dieses Tool extrahiert automatisch Anrufer-, Agenten-, Mandanten-, Kommunikationskanal- und Unterhaltungsdetails aus der Aktivität.

from microsoft_agents.hosting.core.turn_context import TurnContext
from microsoft_agents_a365.observability.core import BaggageBuilder
from microsoft_agents_a365.observability.hosting.scope_helpers.populate_baggage import populate

builder = BaggageBuilder()
populate(builder, turn_context)

with builder.build():
    # Baggage is auto-populated from the TurnContext activity
    pass

import { BaggageBuilder } from '@microsoft/agents-a365-observability';

// Create and apply baggage context
const baggageScope = new BaggageBuilder()
  // Core identifiers
  .tenantId('tenant-123')
  .agentId('agent-456')
  .conversationId('conv-789')
  .build();

// Execute operations within the baggage context
baggageScope.run(() => {
  // All spans created within this context will inherit the baggage values

  // Invoke another agent
  const agentScope = InvokeAgentScope.start(request, scopeDetails, agentDetails);
  // ... agent logic

  // Execute tools
  const toolScope = ExecuteToolScope.start(request, toolDetails, agentDetails);
  // ... tool logic
});

Verwenden Sie das fromTurnContext-Hilfsprogramm im @microsoft/agents-a365-observability-hosting-Paket, um das BaggageBuilder automatisch aus dem TurnContext auszufüllen. Dieses Tool extrahiert automatisch Anrufer-, Agenten-, Mandanten-, Kommunikationskanal- und Unterhaltungsdetails aus der Aktivität.

import { BaggageBuilder } from '@microsoft/agents-a365-observability';
import { BaggageBuilderUtils } from '@microsoft/agents-a365-observability-hosting';

const baggageScope = BaggageBuilderUtils.fromTurnContext(new BaggageBuilder(), context)
  .invokeAgentServer(context.activity.serviceUrl, 3978)
  .build();

await baggageScope.run(async () => {
  // Baggage is auto-populated from the TurnContext activity
});

using Microsoft.Agents.A365.Observability.Runtime.Common;

using var baggageScope = new BaggageBuilder()
    .TenantId("tenant-123")
    .AgentId("agent-456")
    .ConversationId("conv-789")
    .Build();
// Any spans started in this context will receive them as attributes.

Verwenden Sie zum automatischen Auffüllen des BaggageBuilder aus dem ITurnContext die Erweiterungsmethode FromTurnContext im Paket Microsoft.Agents.A365.Observability.Hosting. Diese Methode extrahiert automatisch Anrufer-, Agent-, Mandanten-, Kanal- und Unterhaltungsdetails aus der Aktivität.

using Microsoft.Agents.A365.Observability.Runtime.Common;
using Microsoft.Agents.A365.Observability.Hosting.Extensions;

using var baggageScope = new BaggageBuilder()
    .FromTurnContext(turnContext)
    .Build();

from microsoft_agents.activity import load_configuration_from_env
from microsoft_agents.authentication.msal import MsalConnectionManager
from microsoft_agents.hosting.aiohttp import CloudAdapter
from microsoft_agents.hosting.core import (
    AgentApplication,
    Authorization,
    MemoryStorage,
    TurnContext,
    TurnState,
)
from microsoft_agents_a365.runtime import (
    get_observability_authentication_scope,
)

agents_sdk_config = load_configuration_from_env(environ)

STORAGE = MemoryStorage()
CONNECTION_MANAGER = MsalConnectionManager(**agents_sdk_config)
ADAPTER = CloudAdapter(connection_manager=CONNECTION_MANAGER)
ADAPTER.use(TranscriptLoggerMiddleware(ConsoleTranscriptLogger()))
AUTHORIZATION = Authorization(STORAGE, CONNECTION_MANAGER, **agents_sdk_config)

AGENT_APP = AgentApplication[TurnState](
    storage=STORAGE, adapter=ADAPTER, authorization=AUTHORIZATION, **agents_sdk_config
)

@AGENT_APP.activity("message", auth_handlers=["AGENTIC"])
async def on_message(context: TurnContext, _state: TurnState):
    aau_auth_token = await AGENT_APP.auth.exchange_token(
                        context,
                        scopes=get_observability_authentication_scope(),
                        auth_handler_id="AGENTIC",
                    )
    # cache this auth token and return via token resolver

Für das digitale Arbeiterszenario, wenn Ihr Agent das Microsoft Agent 365 Observability Hosting Library-Paket verwendet, verwenden Sie AgenticTokenCache, um die Tokenzwischenspeicherung automatisch zu handhaben. Registrieren Sie das Token einmal pro Agent und Mandant während eines Aktivitäts-Handlers, und übergeben Sie es in Ihrer Observability-Konfiguration cache.get_observability_token als token_resolver.

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.hosting.token_cache_helpers import (
    AgenticTokenCache,
    AgenticTokenStruct,
)
from microsoft_agents_a365.runtime import get_observability_authentication_scope

# Create a shared cache instance
token_cache = AgenticTokenCache()

# Use the cache as your token resolver in configure()
configure(
    service_name="my-agent-service",
    service_namespace="my.namespace",
    token_resolver=token_cache.get_observability_token,
)

@AGENT_APP.activity("message", auth_handlers=["AGENTIC"])
async def on_message(context: TurnContext, _state: TurnState):
    token_cache.register_observability(
        agent_id="agent-456",
        tenant_id="tenant-123",
        token_generator=AgenticTokenStruct(
            authorization=AGENT_APP.auth,
            turn_context=context,
        ),
        observability_scopes=get_observability_authentication_scope(),
    )

import {
  TurnState,
  AgentApplication,
  MemoryStorage,
  TurnContext,
} from '@microsoft/agents-hosting';
import { ActivityTypes } from '@microsoft/agents-activity';
import { getObservabilityAuthenticationScope } from '@microsoft/agents-a365-runtime';

interface ConversationState {
  count: number;
}
type ApplicationTurnState = TurnState<ConversationState>;

const storage = new MemoryStorage();

export const agentApplication = new AgentApplication<ApplicationTurnState>({
  authorization: {
    agentic: {}, // We have the type and scopes set in the .env file
  },
  storage,
});

agentApplication.onActivity(
  ActivityTypes.Message,
  async (context: TurnContext, state: ApplicationTurnState) => {
    const aauAuthToken = await agentApplication.authorization.exchangeToken(context, 'agentic', {
      scopes: getObservabilityAuthenticationScope()
    });
    // cache this auth token and return via token resolver
  }
);

Wenn Ihr Agent das @microsoft/agents-a365-observability-hosting Paket verwendet, nutzen Sie im Szenario des digitalen Arbeiters AgenticTokenCacheInstance für die automatische Token-Cache-Verarbeitung. Rufen Sie RefreshObservabilityToken einmal pro Agent und Mandant während des Aktivitätshandlers auf, und übergeben Sie es AgenticTokenCacheInstance.getObservabilityToken als tokenResolver in Ihrer Observability-Konfiguration.

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { AgenticTokenCacheInstance } from '@microsoft/agents-a365-observability-hosting';
import { getObservabilityAuthenticationScope } from '@microsoft/agents-a365-runtime';

// Use the cache as your token resolver in configure()
const builder = ObservabilityManager.configure(builder =>
  builder
    .withService('my-agent-service', '1.0.0')
    .withTokenResolver((agentId, tenantId) =>
      AgenticTokenCacheInstance.getObservabilityToken(agentId, tenantId)
    )
);

builder.start();

agentApplication.onActivity(
  ActivityTypes.Message,
  async (context: TurnContext, state: ApplicationTurnState) => {
    const agentId = context.activity.recipient?.agenticAppId || '';
    const tenantId = context.activity.recipient?.tenantId || '';

    await AgenticTokenCacheInstance.RefreshObservabilityToken(
      agentId,
      tenantId,
      context,
      agentApplication.authorization,
      getObservabilityAuthenticationScope()
    );
  }
);

Stellen Sie einen Tokenlöser bereit, indem Sie sich bei einer Agent365ExporterOptions registrierenTokenResolver. Der Delegierte empfängt agentId und tenantId und gibt das Authentifizierungstoken zurück.

using Microsoft.Agents.A365.Observability.Runtime.Tracing.Exporters;

builder.Services.AddSingleton(sp =>
    {
        return new Agent365ExporterOptions
        {
            TokenResolver = async (agentId, tenantId) =>
            {
                // Implement your token retrieval logic here
                return await GetTokenAsync(agentId, tenantId);
            }
        };
    });

Für das Szenario des digitalen Arbeiters: Wenn Ihr Agent das Microsoft.Agents.A365.Observability.Hosting NuGet-Paket verwendet, nutzen Sie die AddAgenticTracingExporter() Methode, um das Token-Caching automatisch durch Dependency Injection zu handhaben.

using Microsoft.Agents.A365.Observability.Hosting;

builder.Services.AddAgenticTracingExporter();

Registrieren Sie das Token in der Agent-Anwendung.

using Microsoft.Agents.Builder;
using Microsoft.Agents.Builder.App.UserAuth;
using Microsoft.Extensions.Logging;
using Microsoft.Agents.A365.Observability.Hosting.Caching;
using Microsoft.Agents.A365.Observability.Runtime.Common;
using System;
using System.Threading.Tasks;

public class MyAgent : AgentApplication
{
    private readonly IExporterTokenCache<AgenticTokenStruct> _agentTokenCache;
    private readonly ILogger<MyAgent> _logger;

    public MyAgent(AgentApplicationOptions options, IExporterTokenCache<AgenticTokenStruct> agentTokenCache, ILogger<MyAgent> logger)
        : base(options)
    {
        _agentTokenCache = agentTokenCache ?? throw new ArgumentNullException(nameof(agentTokenCache));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }

    protected async Task MessageActivityAsync(ITurnContext turnContext, ITurnState turnState, CancellationToken cancellationToken)
    {
        using var baggageScope = new BaggageBuilder()
            .TenantId(turnContext.Activity.Recipient.TenantId)
            .AgentId(turnContext.Activity.Recipient.AgenticAppId)
            .Build();

        try
        {
            _agentTokenCache.RegisterObservability(
                turnContext.Activity.Recipient.AgenticAppId,
                turnContext.Activity.Recipient.TenantId,
                new AgenticTokenStruct(
                    userAuthorization: UserAuthorization,
                    turnContext: turnContext,
                    authHandlerName: "AGENTIC"
                ),
                EnvironmentUtils.GetObservabilityAuthenticationScope()
            );
        }
        catch (Exception ex)
        {
            _logger.LogWarning($"Error registering for observability: {ex.Message}");
        }
    }
}

Installieren des Pakets.

pip install microsoft-agents-a365-observability-extensions-semantic-kernel

Konfigurieren der Beobachtbarkeit

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.extensions.semantickernel.trace_instrumentor import SemanticKernelInstrumentor

# Configure observability
configure(
    service_name="my-semantic-kernel-agent",
    service_namespace="ai.agents"
)

# Enable auto-instrumentation
instrumentor = SemanticKernelInstrumentor()
instrumentor.instrument()

# Your Semantic Kernel code is now automatically traced

Semantischer Kernel wird mit JavaScript nicht unterstützt.

Abhängigkeiten zur Serviceauflistung hinzufügen.

using Microsoft.Agents.A365.Observability.Extensions.SemanticKernel;

builder.AddA365Tracing(configure: config => config.WithSemanticKernel());

Setzen Sie AgentId und TenantId durch Verwendung von BaggageBuilder. Stellen Sie sicher, dass die ID, die Sie beim Erstellen eines ChatCompletionAgent verwenden, mit der Agenten-ID übereinstimmt, die Sie an BaggageBuilder weitergeben.

using Microsoft.Agents.A365.Observability.Extensions.SemanticKernel;
using Microsoft.Agents.A365.Observability.Runtime.Common;
public class MyAgent
{
    public async Task<AgentResponse> ProcessUserRequest(string userInput)
    {
      using var baggageScope = new BaggageBuilder()
          .AgentId(<your-agent-id>) // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. 
          .TenantId(<your-tenant-id>) // NOTE: This will be the tenant ID with which the TokenResolver delegate is invoked.
          .Build();
      
      var chatCompletionAgent = new ChatCompletionAgent
      {
          // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. Should match above.
          Id = <your-agent-id>,
          ...
      };
    }
}

Installieren des Pakets.

pip install microsoft-agents-a365-observability-extensions-openai

Konfigurieren der Beobachtbarkeit

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.extensions.openai import OpenAIAgentsTraceInstrumentor

# Configure observability
configure(
    service_name="my-openai-agent",
    service_namespace="ai.agents"
)

# Enable auto-instrumentation
instrumentor = OpenAIAgentsTraceInstrumentor()
instrumentor.instrument()

# Your OpenAI Agents code is now automatically traced

Installieren des Pakets.

npm install @microsoft/agents-a365-observability-extensions-openai

Konfigurieren der Beobachtbarkeit

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { OpenAIAgentsTraceInstrumentor } from '@microsoft/agents-a365-observability-extensions-openai';

// Configure observability first
const sdk = ObservabilityManager.configure((builder) =>
  builder
    .withService('My Agent Service', '1.0.0')
);

// Create and enable the instrumentor
const instrumentor = new OpenAIAgentsTraceInstrumentor({
  enabled: true,
  tracerName: 'openai-agents-tracer',
  tracerVersion: '1.0.0'
});

sdk.start();

instrumentor.enable();

Abhängigkeiten zur Serviceauflistung hinzufügen.

using Microsoft.Agents.A365.Observability.Extensions.OpenAI;

builder.AddA365Tracing(configure: config => config.WithOpenAI());

Setzen Sie AgentId und TenantId durch Verwendung von BaggageBuilder. Für Toolaufrufe starten Sie einen Trace, indem Sie Trace() auf einer ChatToolCall-Instanz verwenden.

using Microsoft.Agents.A365.Observability.Extensions.OpenAI;
using Microsoft.Agents.A365.Observability.Runtime.Common;

public class MyAgent
{
    public async Task<AgentResponse> ProcessUserRequest(string userInput)
    {
      using var baggageScope = new BaggageBuilder()
          .AgentId(<your-agent-id>) // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. 
          .TenantId(<your-tenant-id>) // NOTE: This will be the tenant ID with which the TokenResolver delegate is invoked.
          .Build();
      
      // NOTE: This will be the agent and tenant ID with which the TokenResolver delegate will be invoked. 
      using var scope = chatToolCall.Trace(agentId: <your-agent-id>, <your-tenant-id>);
    }
}

Installieren des Pakets.

pip install microsoft-agents-a365-observability-extensions-agent-framework

Konfigurieren der Beobachtbarkeit

from microsoft_agents_a365.observability.core import configure
from microsoft_agents_a365.observability.extensions.agentframework import (
    AgentFrameworkInstrumentor,
)

# Configure observability
configure(
    service_name="AgentFrameworkTracingWithAzureOpenAI",
    service_namespace="AgentFrameworkTesting",
)

# Enable auto-instrumentation
AgentFrameworkInstrumentor().instrument()

Agent Framework wird mit JavaScript nicht unterstützt.

Abhängigkeiten zur Serviceauflistung hinzufügen.

using Microsoft.Agents.A365.Observability.Extensions.AgentFramework;

builder.AddA365Tracing(configure: config => config.WithAgentFramework());

Setzen Sie AgentId und TenantId durch Verwendung von BaggageBuilder.

using Microsoft.Agents.A365.Observability.Runtime.Common;

public class MyAgent : AgentApplication
{
    protected async Task MessageActivityAsync(ITurnContext turnContext, ITurnState turnState, CancellationToken cancellationToken)
    {
      using var baggageScope = new BaggageBuilder()
          .AgentId(<your-agent-id>) // NOTE: This will be the agent ID with which the TokenResolver delegate is invoked. 
          .TenantId(<your-tenant-id>) // NOTE: This will be the tenant ID with which the TokenResolver delegate is invoked.
          .Build();
    }
}

Installieren des Pakets.

pip install microsoft-agents-a365-observability-extensions-langchain

Konfigurieren der Beobachtbarkeit

from microsoft_agents_a365.observability.core.config import configure
from microsoft_agents_a365.observability.extensions.langchain import CustomLangChainInstrumentor

# Configure observability
configure(
    service_name="my-langchain-agent",
    service_namespace="ai.agents"
)

# Enable auto-instrumentation
CustomLangChainInstrumentor()

# Your LangChain code is now automatically traced

Installieren des Pakets.

npm install @microsoft/agents-a365-observability-extensions-langchain

Konfigurieren der Beobachtbarkeit

import { ObservabilityManager } from '@microsoft/agents-a365-observability';
import { LangChainTraceInstrumentor } from '@microsoft/agents-a365-observability-extensions-langchain';
import * as LangChainCallbacks from '@langchain/core/callbacks/manager';

// Configure observability first
const sdk = ObservabilityManager.configure((builder) =>
  builder
    .withService('My Agent Service', '1.0.0')
);

sdk.start();

// Enable LangChain auto-instrumentation
LangChainTraceInstrumentor.instrument(LangChainCallbacks);

// Your LangChain code is now automatically traced

LangChain wird mit .NET nicht unterstützt.

from microsoft_agents_a365.observability.core import (
    InvokeAgentScope,
    InvokeAgentScopeDetails,
    AgentDetails,
    CallerDetails,
    UserDetails,
    Channel,
    Request,
    ServiceEndpoint,
)

agent_details = AgentDetails(
    agent_id="agent-456",
    agent_name="My Agent",
    agent_description="An AI agent powered by Azure OpenAI",
    agentic_user_id="auid-123",
    agentic_user_email="agent@contoso.com",
    agent_blueprint_id="blueprint-789",
    tenant_id="tenant-123",
)

scope_details = InvokeAgentScopeDetails(
    endpoint=ServiceEndpoint(hostname="myagent.contoso.com", port=443),
)

request = Request(
    content="User asks a question",
    session_id="session-42",
    conversation_id="conv-xyz",
    channel=Channel(name="msteams"),
)

caller_details = CallerDetails(
    user_details=UserDetails(
        user_id="user-123",
        user_email="jane.doe@contoso.com",
        user_name="Jane Doe",
    ),
)

with InvokeAgentScope.start(request, scope_details, agent_details, caller_details):
    # Perform agent invocation logic
    response = call_agent(...)

import {
  InvokeAgentScope,
  InvokeAgentScopeDetails,
  AgentDetails,
  CallerDetails,
  UserDetails,
  Channel,
  Request,
  ServiceEndpoint,
} from '@microsoft/agents-a365-observability';

// Use the same agentDetails instance across all scopes in a request
const agentDetails: AgentDetails = {
  agentId: 'agent-456',
  agentName: 'Email Assistant',
  agentDescription: 'An AI agent powered by Azure OpenAI',
  agentAuid: 'auid-123',
  agentEmail: 'agent@contoso.com',
  agentBlueprintId: 'blueprint-789',
  tenantId: 'tenant-123',
};

const scopeDetails: InvokeAgentScopeDetails = {
  endpoint: { host: 'myagent.contoso.com', port: 443 } as ServiceEndpoint,
};

// Use the same request instance across all scopes in a request
const request: Request = {
  content: 'Please help me organize my emails',
  sessionId: 'session-42',
  conversationId: 'conv-xyz',
  channel: { name: 'msteams' } as Channel,
};

// Optional: Caller details (human user, or agent-to-agent)
const callerDetails: CallerDetails = {
  userDetails: {
    userId: 'user-123',
    userEmail: 'jane.doe@contoso.com',
    userName: 'Jane Doe',
  } as UserDetails,
};

const scope = InvokeAgentScope.start(request, scopeDetails, agentDetails, callerDetails);

try {
  await scope.withActiveSpanAsync(async () => {
    // Record input messages
    scope.recordInputMessages(['Please help me organize my emails', 'Focus on urgent items']);

    // Your agent invocation logic here
    const response = await invokeAgent(request.content);

    // Record output messages
    scope.recordOutputMessages(['I found 15 urgent emails', 'Here is your organized inbox']);
  });
} catch (error) {
  scope.recordError(error as Error);
  throw error;
} finally {
  scope.dispose();
}

Wenn Ihr Agent das @microsoft/agents-a365-observability-hosting Paket verwendet, können Sie mit ScopeUtils.populateInvokeAgentScopeFromTurnContext den Bereich mit Agentdetails, Anruferdetails und Kanalinformationen erstellen, die automatisch von der TurnContext abgeleitet werden.

import { InvokeAgentScopeDetails, AgentDetails, ServiceEndpoint } from '@microsoft/agents-a365-observability';
import { ScopeUtils } from '@microsoft/agents-a365-observability-hosting';

const agentDetails: AgentDetails = { agentId: 'agent-456' };
const scopeDetails: InvokeAgentScopeDetails = {
  endpoint: { host: 'myagent.contoso.com', port: 443 } as ServiceEndpoint,
};

const scope = ScopeUtils.populateInvokeAgentScopeFromTurnContext(
  agentDetails,
  scopeDetails,
  context,     // TurnContext
  authToken    // authentication token string
);

try {
  await scope.withActiveSpanAsync(async () => {
    // Agent details, caller details, and channel are auto-populated from context
    const response = await invokeAgent(context.activity.text);
    scope.recordOutputMessages([response]);
  });
} finally {
  scope.dispose();
}

using System;
using System.Threading.Tasks;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

public class MyAgent
{
    public async Task<AgentResponse> ProcessUserRequest(string userInput)
    {
        var agentDetails = new AgentDetails(
            agentId: "agent-456",
            agentName: "MyAgent",
            agentDescription: "Handles user requests.",
            agenticUserId: "auid-123",
            agenticUserEmail: "agent@contoso.com",
            agentBlueprintId: "blueprint-789",
            tenantId: "tenant-123"
        );

        var scopeDetails = new InvokeAgentScopeDetails(
            endpoint: new Uri("https://myagent.contoso.com")
        );

        var request = new Request(
            content: userInput,
            sessionId: "session-abc",
            channel: new Channel("msteams"),
            conversationId: "conv-xyz"
        );

        var callerDetails = new CallerDetails(
            userDetails: new UserDetails(
                userId: "user-123",
                userEmail: "jane.doe@contoso.com",
                userName: "Jane Doe"
            )
        );

        // Start the scope
        using var scope = InvokeAgentScope.Start(
            request: request,
            scopeDetails: scopeDetails,
            agentDetails: agentDetails,
            callerDetails: callerDetails
        );

        // Record input messages
        scope.RecordInputMessages(new[] { userInput });

        // ... your agent logic here ...

        var output = $"Processed: {userInput}";
        scope.RecordOutputMessages(new[] { output });

        return new AgentResponse { Content = output };
    }
}

public class AgentResponse
{
    public string Content { get; set; }
}

from microsoft_agents_a365.observability.core import (
    ExecuteToolScope,
    ToolCallDetails,
    Request,
    ServiceEndpoint,
)

# Use the same agent_details and request instances from the InvokeAgentScope example above

tool_details = ToolCallDetails(
    tool_name="summarize",
    tool_type="function",
    tool_call_id="tc-001",
    arguments="{'text': '...'}",
    description="Summarize provided text",
    endpoint=ServiceEndpoint(hostname="tools.contoso.com", port=8080),
)

with ExecuteToolScope.start(request, tool_details, agent_details) as scope:
    result = run_tool(tool_details)
    scope.record_response(result)

import { ExecuteToolScope, ToolCallDetails } from '@microsoft/agents-a365-observability';

// Use the same agentDetails and request instances from the InvokeAgentScope example above

const toolDetails: ToolCallDetails = {
  toolName: 'email-search',
  arguments: JSON.stringify({ query: 'from:boss@company.com', limit: 10 }),
  toolCallId: 'tool-call-456',
  description: 'Search emails by criteria',
  toolType: 'function',
  endpoint: {
    host: 'tools.contoso.com',
    port: 8080,  // Will be recorded since not 443
    protocol: 'https'
  },
};

const scope = ExecuteToolScope.start(request, toolDetails, agentDetails);

try {
  return await scope.withActiveSpanAsync(async () => {
    // Execute the tool
    const result = await searchEmails(toolDetails.arguments);

    // Record the tool execution result
    scope.recordResponse(result);

    return result;
  });
} catch (error) {
  scope.recordError(error as Error);
  throw error;
} finally {
  scope.dispose();
}

Wenn Ihr Agent das @microsoft/agents-a365-observability-hosting-Paket verwendet, verwenden Sie ScopeUtils.populateExecuteToolScopeFromTurnContext, um den Bereich mit den Agentendaten zu erstellen, die automatisch von TurnContext abgeleitet werden.

import { ToolCallDetails } from '@microsoft/agents-a365-observability';
import { ScopeUtils } from '@microsoft/agents-a365-observability-hosting';

const toolDetails: ToolCallDetails = {
  toolName: 'email-search',
  arguments: JSON.stringify({ query: 'from:boss@company.com' }),
  toolCallId: 'tool-call-456',
  toolType: 'function',
};

const scope = ScopeUtils.populateExecuteToolScopeFromTurnContext(
  toolDetails,
  context,     // TurnContext
  authToken    // authentication token string
);

try {
  await scope.withActiveSpanAsync(async () => {
    const result = await searchEmails(toolDetails.arguments);
    scope.recordResponse(JSON.stringify(result));
  });
} finally {
  scope.dispose();
}

using System;
using System.Threading.Tasks;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

// Use the same agentDetails and request instances from the InvokeAgentScope example above

var toolCallDetails = new ToolCallDetails(
    toolName: "summarize",
    arguments: "{\"text\": \"...\"}",
    toolCallId: "tc-001",
    description: "Summarize provided text",
    toolType: "function",
    endpoint: new Uri("https://tools.contoso.com:8080")
);

using var scope = ExecuteToolScope.Start(
    request: request,
    details: toolCallDetails,
    agentDetails: agentDetails
);

// ... your tool logic here ...

scope.RecordResponse("{\"summary\": \"The text was summarized.\"}");

from microsoft_agents_a365.observability.core import (
    InferenceScope,
    InferenceCallDetails,
    InferenceOperationType,
)

# Use the same agent_details and request instances from the InvokeAgentScope example above

inference_details = InferenceCallDetails(
    operationName=InferenceOperationType.CHAT,
    model="gpt-4o-mini",
    providerName="azure-openai",
    inputTokens=123,
    outputTokens=456,
    finishReasons=["stop"],
)

with InferenceScope.start(request, inference_details, agent_details) as scope:
    completion = call_llm(...)
    scope.record_output_messages([completion.text])
    scope.record_input_tokens(completion.usage.input_tokens)
    scope.record_output_tokens(completion.usage.output_tokens)

import { InferenceScope, InferenceDetails, InferenceOperationType } from '@microsoft/agents-a365-observability';

// Use the same agentDetails and request instances from the InvokeAgentScope example above

const inferenceDetails: InferenceDetails = {
  operationName: InferenceOperationType.CHAT,
  model: 'gpt-4o-mini',
  providerName: 'azure-openai',
};

const scope = InferenceScope.start(request, inferenceDetails, agentDetails);

try {
  return await scope.withActiveSpanAsync(async () => {
    // Record input messages
    scope.recordInputMessages(['Summarize the following emails for me...']);

    // Call the LLM
    const response = await callLLM();

    // Record detailed telemetry with granular methods
    scope.recordOutputMessages(['Here is your email summary...']);
    scope.recordInputTokens(145);
    scope.recordOutputTokens(82);
    scope.recordFinishReasons(['stop']);

    return response.text;
  });
} catch (error) {
  scope.recordError(error as Error);
  throw error;
} finally {
  scope.dispose();
}

Wenn Ihr Agent das @microsoft/agents-a365-observability-hosting Paket verwendet, können Sie den Geltungsbereich mit den Details des Agents erstellen, die automatisch von der ScopeUtils.populateInferenceScopeFromTurnContext abgeleitet werden.

import { InferenceDetails, InferenceOperationType } from '@microsoft/agents-a365-observability';
import { ScopeUtils } from '@microsoft/agents-a365-observability-hosting';

const inferenceDetails: InferenceDetails = {
  operationName: InferenceOperationType.CHAT,
  model: 'gpt-4o-mini',
  providerName: 'azure-openai',
};

const scope = ScopeUtils.populateInferenceScopeFromTurnContext(
  inferenceDetails,
  context,     // TurnContext
  authToken    // authentication token string
);

try {
  await scope.withActiveSpanAsync(async () => {
    const response = await callLLM();
    scope.recordOutputMessages([response.text]);
    scope.recordInputTokens(response.usage.inputTokens);
    scope.recordOutputTokens(response.usage.outputTokens);
  });
} finally {
  scope.dispose();
}

using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

// Use the same agentDetails and request instances from the InvokeAgentScope example above

var inferenceDetails = new InferenceCallDetails(
    operationName: InferenceOperationType.Chat,
    model: "gpt-4o-mini",
    providerName: "Azure OpenAI",
    inputTokens: 123,
    outputTokens: 456,
    finishReasons: new[] { "stop" }
);

using var scope = InferenceScope.Start(
    request: request,
    details: inferenceDetails,
    agentDetails: agentDetails
);

// ... your inference logic here ...

scope.RecordOutputMessages(new[] { "AI response message" });
scope.RecordInputTokens(123);
scope.RecordOutputTokens(456);

from microsoft_agents_a365.observability.core import (
    OutputScope,
    Response,
    SpanDetails,
)

# Use the same agent_details and request instances from the InvokeAgentScope example above

# Get the parent context from the originating scope
parent_context = invoke_scope.get_context()

response = Response(messages=["Here is your organized inbox with 15 urgent emails."])

with OutputScope.start(
    request,
    response,
    agent_details,
    span_details=SpanDetails(parent_context=parent_context),
):
    # Output messages are recorded automatically from the response
    pass

import { OutputScope, OutputResponse, SpanDetails } from '@microsoft/agents-a365-observability';

// Use the same agentDetails and request instances from the InvokeAgentScope example above

// Get the parent context from the originating scope
const parentContext = invokeScope.getSpanContext();

const response: OutputResponse = {
  messages: ['Here is your organized inbox with 15 urgent emails.'],
};

const scope = OutputScope.start(
  request,
  response,
  agentDetails,
  undefined, // userDetails
  { parentContext } as SpanDetails
);

// Output messages are recorded automatically from the response
scope.dispose();

using Microsoft.Agents.A365.Observability.Runtime.Tracing.Contracts;
using Microsoft.Agents.A365.Observability.Runtime.Tracing.Scopes;

// Use the same agentDetails and request instances from the InvokeAgentScope example above

// Get the parent context from the originating scope
var parentContext = invokeScope.GetActivityContext();

var response = new Response(new[] { "Here is your organized inbox with 15 urgent emails." });

using var scope = OutputScope.Start(
    request: request,
    response: response,
    agentDetails: agentDetails,
    spanDetails: new SpanDetails(parentContext: parentContext)
);
// Output messages are recorded automatically from the response

Legen Sie die Umgebungsvariable ENABLE_A365_OBSERVABILITY_EXPORTER auf false fest. Diese Einstellung exportiert Bereiche (Ablaufverfolgungen) in die Konsole.

Um Exportfehler zu untersuchen, aktivieren Sie die ausführliche Protokollierung, indem Sie ENABLE_A365_OBSERVABILITY_EXPORTER auf true setzen und die Debug-Protokollierung beim Start Ihrer Anwendung konfigurieren.

import logging

logging.basicConfig(level=logging.DEBUG)
logging.getLogger("microsoft_agents_a365.observability.core").setLevel(logging.DEBUG)

# Or target only the exporter:
logging.getLogger(
    "microsoft_agents_a365.observability.core.exporters.agent365_exporter"
).setLevel(logging.DEBUG)

Schlüsselprotokollmeldungen:

DEBUG  Token resolved for agent {agentId} tenant {tenantId}
DEBUG  Exporting {n} spans to {url}
DEBUG  HTTP 200 - correlation ID: abc-123
ERROR  Token resolution failed: {error}
ERROR  HTTP 401 exporting spans - correlation ID: abc-123
INFO   No spans with tenant/agent identity found; nothing exported.

Legen Sie die Umgebungsvariable ENABLE_A365_OBSERVABILITY_EXPORTER auf false fest. Diese Einstellung exportiert Bereiche (Ablaufverfolgungen) in die Konsole.

Um Exportfehler zu untersuchen, legen Sie Umgebungsvariablen in .env oder Shell fest:

# Enable the Agent365 exporter
ENABLE_A365_OBSERVABILITY_EXPORTER=true

# Enable verbose logging
A365_OBSERVABILITY_LOG_LEVEL=info|warn|error

Überprüfen Sie die Konsolenausgabe für Nachrichten wie:

[INFO]  [Agent365Exporter] Exporting 245 spans
[INFO]  [Agent365Exporter] Partitioned into 3 identity groups (2 spans skipped)
[INFO]  [Agent365Exporter] Token resolved successfully via tokenResolver
[EVENT] export-group succeeded in 98ms {"tenantId":"...","agentId":"...","correlationId":"abc-123"}
[ERROR] [Agent365Exporter] Failed with status 401, correlation ID: abc-123
[WARN]  export-partition-span-missing-identity: 5 spans skipped due to missing tenant or agent ID

Optional können Sie einen benutzerdefinierten Logger verwenden, um Exportereignisse in eine Datei zu erfassen:

import { setLogger, ExporterEventNames } from '@microsoft/agents-a365-observability';

setLogger({
  info: (msg, ...args) => myLogger.info(msg, ...args),
  warn: (msg, ...args) => myLogger.warn(msg, ...args),
  error: (msg, ...args) => myLogger.error(msg, ...args),
  event: (eventType: ExporterEventNames, isSuccess: boolean, durationMs: number,
          message?: string, details?: Record<string, string>) => {
    myLogger.info({ eventType, isSuccess, durationMs, message, ...details });
  }
});

Legen Sie EnableAgent365Exporter auf false in appsettings.json fest. Diese Einstellung exportiert Bereiche (Ablaufverfolgungen) in die Konsole.

Um Exportfehler zu untersuchen, konfigurieren Sie detaillierte Protokollierung in appsettings.json:

{
  "EnableAgent365Exporter": "True",
  "Logging": {
    "LogLevel": {
      "Microsoft.Agents.A365.Observability": "Debug"
    }
  }
}

Oder legen Sie Umgebungsvariablen fest:

EnableAgent365Exporter=True
A365_OBSERVABILITY_DOMAIN_OVERRIDE=https://your-test-endpoint.example.com
A365_OBSERVABILITY_SCOPE_OVERRIDE=https://api.powerplatform.com/.default

Schlüsselprotokollmeldungen:

info: Agent365ExporterCore: Obtained token for agent {agentId} tenant {tenantId}.
info: Agent365ExporterCore: Sending {count} spans to {requestUri} for agent {agentId} tenant {tenantId}.
info: Agent365ExporterCore: HTTP {statusCode} exporting spans. 'x-ms-correlation-id': '{correlationId}'.
error: Agent365Exporter: Exception exporting spans: {exception}
warn: Agent365ExporterCore: No token obtained for agent {agentId} tenant {tenantId}. Skipping export.

• Eigenschaften, die Sie mit der BaggageBuilder-Klasse festlegen, könnten von den Eigenschaften der jeweiligen Bereiche festgelegt oder überschrieben werden.

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode InvokeAgentScope.start.

  Daten	Beschreibung
  invoke_agent_details.details.agent_id	Der eindeutige Bezeichner für den KI-Agent
  invoke_agent_details.details.agent_name	Der lesbare Name des KI-Agenten
  invoke_agent_details.details.agent_auid	Die Agent-Benutzer-ID (AUID)
  invoke_agent_details.details.agent_upn	Der Benutzerprinzipalname (UPN) des Agents
  invoke_agent_details.details.agent_blueprint_id	Die Blueprint-/Anwendungs-ID des Agents
  invoke_agent_details.details.tenant_id	Die Mandanten-ID für den Agenten
  invoke_agent_details.details.conversation_id	Der Bezeichner für das Gespräch oder die Sitzung
  invoke_agent_details.endpoint	Der Endpunkt für den Agent-Aufruf
  tenant_details.tenant_id	Der eindeutige Bezeichner für den Mandanten
  request.content	Der Nutzlastinhalt, der zum Aufruf an den Agenten gesendet wird
  request.execution_type	Invocation-Typ, der den Ursprung der Anfrage angibt (zum Beispiel HumanToAgent oder AgentToAgent)
  caller_details.caller_id	Der eindeutige Bezeichner für den Aufrufer
  caller_details.caller_upn	Der Benutzerprinzipalname (UPN) des Aufrufers
  caller_details.caller_user_id	Die Benutzer-ID des Anrufers
  caller_details.tenant_id	Die Mandanten-ID des Anrufers

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode ExecuteToolScope.start.

  Daten	Beschreibung
  details.tool_name	Der Name des Tools, das ausgeführt wird
  details.arguments	Werkzeugargumente oder -parameter
  details.tool_call_id	Der eindeutige Bezeichner für den Toolaufruf
  details.tool_type	Der Typ des auszuführenden Tools
  details.endpoint	Wenn ein externer Werkzeugaufruf durchgeführt wird
  agent_details.agent_id	Der eindeutige Bezeichner für den KI-Agent
  agent_details.agent_name	Der lesbare Name des KI-Agenten
  agent_details.agent_auid	Die Agent-Benutzer-ID
  agent_details.agent_upn	Der Benutzerprinzipalname (UPN) des Agents
  agent_details.agent_blueprint_id	Der Agenten-Blueprint oder die Anwendungs-ID
  agent_details.tenant_id	Die Mandanten-ID des Agents.
  agent_details.conversation_id	Die Konversationskennung für den Agentenaufruf.
  tenant_details.tenant_id	Die Mandanten-ID des Agents.

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode InferenceScope.start.

  Daten	Beschreibung
  details.operationName	Der Operationsname oder -typ für die Schlussfolgerung
  details.model	Der Modellname oder die Kennung
  details.providerName	Der Name des Anbieters
  agent_details.agent_id	Der eindeutige Bezeichner für den KI-Agent
  agent_details.agent_name	Der lesbare Name des KI-Agenten
  agent_details.agent_auid	Die Agent-Benutzer-ID (AUID)
  agent_details.agent_upn	Der Benutzerprinzipalname (UPN) des Agents
  agent_details.agent_blueprint_id	Der Agenten-Blueprint oder die Anwendungs-ID
  agent_details.tenant_id	Der eindeutige Bezeichner für den Mandanten
  agent_details.conversation_id	Der Bezeichner für das Gespräch oder die Sitzung
  tenant_details.tenant_id	Der eindeutige Bezeichner für den Mandanten
  request.content	Der Nutzlastinhalt wurde dem Agent für Rückschlüsse übermittelt
  request.execution_type	Invocation-Typ, der den Ursprung der Anfrage angibt (zum Beispiel HumanToAgent oder AgentToAgent)
  request.source_metadata	Stellen Sie die Kanalinformationen dar

• Eigenschaften, die du mit der BaggageBuilder-Klasse setzt, können von den Eigenschaften der jeweiligen Scopes festgelegt oder überschrieben werden.

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode InvokeAgentScope.start.

  Daten	Beschreibung
  agentDetails.agentId	Der eindeutige Bezeichner für den KI-Agent
  agentDetails.agentName	Der lesbare Name des KI-Agenten
  agentDetails.agentAuid	Die Agent-Benutzer-ID (AUID)
  agentDetails.agentEmail	Die E-Mail-Adresse des Agents
  agentDetails.agentBlueprintId	Die Blueprint-/Anwendungs-ID des Agents
  agentDetails.tenantId	Die Mandanten-ID für den Agenten
  scopeDetails.endpoint.host	Die Host-Adresse des Endpunkts für den Agentenaufruf
  scopeDetails.endpoint.port	Die Portnummer des Endpunkts für den Agentenaufruf
  request.content	Der Inhalt der Anfragenutzlast für den Agent-Aufruf
  request.conversationId	Der Bezeichner für das Gespräch oder die Sitzung
  request.sessionId	Die Sitzungs-ID für den Agentaufruf
  request.channel.name	Kanalinformationen wie (msteams, email, und so weiter)
  callerDetails.userDetails.userId	Der eindeutige Bezeichner für den Aufrufer
  callerDetails.userDetails.userName	Der Anzeigename des Anrufers
  callerDetails.userDetails.userEmail	Die E-Mail-Adresse des Anrufers

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode ExecuteToolScope.start.

  Daten	Beschreibung
  details.toolName	Der Name des Tools, das ausgeführt wird
  details.arguments	Werkzeugargumente oder -parameter
  details.toolCallId	Der eindeutige Bezeichner für den Toolaufruf
  details.toolType	Der Typ des auszuführenden Tools
  details.endpoint.host	Die Host-Adresse des Endpunkts für die Ausführung des Werkzeugs. Erforderlich, wenn externer Anruf tätigt wird
  details.endpoint.port	Die Portnummer des Endpunkts für die Ausführung des Werkzeugs. Erforderlich, wenn externer Anruf tätigt wird
  agentDetails.agentId	Der eindeutige Bezeichner für den KI-Agent
  agentDetails.agentName	Der lesbare Name des KI-Agenten
  agentDetails.tenantId	Die Mandanten-ID für den Agenten
  request.conversationId	Der Bezeichner für das Gespräch oder die Sitzung

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode InferenceScope.start.

  Daten	Beschreibung
  details.operationName	Der Operationsname oder -typ für die Schlussfolgerung
  details.model	Der Modellname oder die Kennung
  details.providerName	Der Name des Anbieters
  agentDetails.agentId	Der eindeutige Bezeichner für den KI-Agent
  agentDetails.agentName	Der lesbare Name des KI-Agenten
  agentDetails.tenantId	Die Mandanten-ID für den Agenten
  request.conversationId	Der Bezeichner für das Gespräch oder die Sitzung

• Eigenschaften, die du mit der BaggageBuilder-Klasse setzt, können von den Eigenschaften der jeweiligen Scopes festgelegt oder überschrieben werden.

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode InvokeAgentScope.Start.

  Daten	Beschreibung
  invokeAgentDetails.details.agentId	Der eindeutige Bezeichner für den Agent.
  invokeAgentDetails.details.agentName	Anzeigename für den Agenten.
  invokeAgentDetails.details.agentAUID	Azure Benutzer-ID (AUID) für den Agent.
  invokeAgentDetails.details.agentUPN	User Principal Name (UPN) für den Agenten.
  invokeAgentDetails.details.agentBlueprintId	Bauplan/Anwendungs-ID für den Agenten.
  invokeAgentDetails.details.tenantId	Die Mandanten-ID des Agents.
  invokeAgentDetails.endpoint	Endpunkt-URI des zu aufrufenden Agenten.
  tenantDetails.tenantId	Die Kennung des Mieters.
  request.content	Der Nutzlastinhalt, der dem Agenten bereitgestellt wird.
  request.executionType	Ausführungstyp, der die Anfrage beschreibt.
  request.sourceMetadata.name	Menschlich lesbarer Name der Quelle. Kanalname.
  conversationId	Die Konversationskennung für den Agentenaufruf.

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode ExecuteToolScope.Start.

  Daten	Beschreibung
  details.toolName	Name des aufgerufenen Werkzeugs.
  details.arguments	Serialisierte Argumente wurden an das Tool weitergegeben.
  details.toolCallId	Identifikator für den Werkzeugaufruf.
  details.toolType	Typklassifizierung für das Werkzeug.
  details.endpoint	Erforderlicher Endpunkt für die Fernausführung des Werkzeugs.
  agentDetails.agentId	Der eindeutige Bezeichner für den Agent.
  agentDetails.agentName	Anzeigename für den Agenten.
  agentDetails.agentAUID	Azure Benutzer-ID (AUID) für den Agent.
  agentDetails.agentUPN	User Principal Name (UPN) für den Agenten.
  agentDetails.agentBlueprintId	Bauplan/Anwendungs-ID für den Agenten.
  agentDetails.tenantId	Die Mandanten-ID des Agents.
  tenantDetails.tenantId	Die Kennung des Mieters.

• Setzen Sie die Eigenschaften in der folgenden Tabelle mit der Methode InferenceScope.Start.

  Daten	Beschreibung
  details.operationName	Telemetriekennung für den Inferenzvorgang.
  details.model	Modellname, der zur Erfüllung der Inferenzanfrage verwendet wird.
  details.providerName	Der Anbieter, der für den Inferenzaufruf verantwortlich ist.
  agentDetails.agentId	Der eindeutige Bezeichner für den Agent.
  agentDetails.agentName	Anzeigename für den Agenten.
  agentDetails.agentAUID	Azure Benutzer-ID (AUID) für den Agent.
  agentDetails.agentUPN	User Principal Name (UPN) für den Agenten.
  agentDetails.agentBlueprintId	Bauplan/Anwendungs-ID für den Agenten.
  agentDetails.tenantId	Die Mandanten-ID des Agents.
  tenantDetails.tenantId	Die Kennung des Mieters.
  parentId	Für die explizite Verwaltung des übergeordneten Bereichs. In den meisten Fällen nicht zwingend erforderlich.