Osservabilità dell'agente

Installa i pacchetti principali di osservabilità e runtime. Tutti gli agenti che usano Agent 365 Observability necessitano di questi pacchetti.

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

Se il tuo agente utilizza il pacchetto Microsoft Agents Hosting, installa il pacchetto di integrazione dell'hosting. Fornisce middleware che popola automaticamente bagagli e ambiti da TurnContexte include la memorizzazione nella cache dei token per l'utilità di esportazione dell'osservabilità.

pip install microsoft-agents-a365-observability-hosting

Se l'agente usa uno dei framework di intelligenza artificiale supportati, installare l'estensione di strumentazione automatica corrispondente per acquisire automaticamente i dati di telemetria senza codice di strumentazione manuale. Per informazioni dettagliate sulla configurazione, vedere Strumentazione automatica.

# 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

Installa i pacchetti principali di osservabilità e runtime. Tutti gli agenti che usano Agent 365 Observability necessitano di questi pacchetti.

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

Se l'agente usa il pacchetto @microsoft/agents-hosting, installare il pacchetto di integrazione dell'hosting. Fornisce middleware che popola automaticamente bagagli e ambiti da TurnContexte include la memorizzazione nella cache dei token per l'utilità di esportazione dell'osservabilità.

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

Se l'agente usa uno dei framework di intelligenza artificiale supportati, installare l'estensione di strumentazione automatica corrispondente per acquisire automaticamente i dati di telemetria senza codice di strumentazione manuale. Per informazioni dettagliate sulla configurazione, vedere Strumentazione automatica.

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

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

Installare il pacchetto principale di osservabilità e runtime. Tutti gli agenti che usano Agent 365 Observability necessitano di questo pacchetto.

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

Se l'agente usa il pacchetto NuGet Microsoft.Agents.A365.Observability.Hosting, installare il pacchetto di integrazione dell'hosting. Fornisce middleware che popola automaticamente i dati da TurnContext e include il caching dei token per l'esportatore di osservabilità.

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

Se l'agente usa uno dei framework di intelligenza artificiale supportati, installare l'estensione di strumentazione automatica corrispondente per acquisire automaticamente i dati di telemetria senza codice di strumentazione manuale. Per informazioni dettagliate sulla configurazione, vedere Strumentazione automatica.

// 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

Imposta la ENABLE_A365_OBSERVABILITY_EXPORTER variabile ambiente a true per l'osservabilità. Questa impostazione esporta i log nel servizio e richiede che venga fornito un oggetto token_resolver . Altrimenti, viene utilizzato l'esportatore della console.

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

Il risolver dei token è escluso dal login alla console.

È possibile personalizzare il comportamento del componente di esportazione passando un'istanza Agent365ExporterOptions a exporter_options. Quando exporter_options viene specificato, ha la precedenza sui token_resolver parametri e 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,
)

Nella tabella seguente vengono descritti i parametri facoltativi per configure().

Nella tabella seguente vengono descritte le proprietà facoltative per Agent365ExporterOptions.

Imposta la ENABLE_A365_OBSERVABILITY_EXPORTER variabile ambiente a true per l'osservabilità. Questa impostazione esporta i log nel servizio e richiede che venga fornito un sistema di risoluzione dei token. Altrimenti, viene utilizzato l'esportatore della console.

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

In alternativa alle variabili di ambiente, è possibile configurare l'osservabilità a livello di codice usando un provider di configurazione tramite withConfigurationProvider il metodo . Se si usano anche metodi di generatore singoli (ad esempio withExporterOptions o withClusterCategory), i singoli metodi del generatore hanno la precedenza sui valori del provider di configurazione.

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

È possibile personalizzare il comportamento del componente di esportazione passando un'istanza Agent365ExporterOptions a withExporterOptions. Questa opzione consente di controllare l'invio in batch, i timeout e la modalità di route.

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

Nella tabella seguente vengono descritte le proprietà facoltative per Agent365ExporterOptions.

Puoi anche fornire un logger personalizzato che implementi l'interfaccia ILogger (info, warn, error, event). Passalo al costruttore usando withCustomLogger.

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

Impostare EnableAgent365Exporter su true in appsettings.json.

In Program.csaggiungi Agent365ExporterOptions alla raccolta di servizi. Questa modifica configura il delegato che l'esportatore di tracce utilizza per recuperare il token.

Aggiungi dipendenze legate all'osservabilità usando 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();

È possibile personalizzare il comportamento dell'esportatore passando un delegato di configurazione e un tipo di esportatore a AddA365Tracing().

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

Nella tabella seguente vengono descritte le proprietà facoltative per 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

È possibile popolare automaticamente BaggageBuilder da TurnContext utilizzando l'helper populate nel pacchetto microsoft-agents-a365-observability-hosting. Questo helper estrae automaticamente il chiamante, l'agente, il tenant, il canale e i dettagli della conversazione dall'attività.

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

È possibile popolare automaticamente BaggageBuilder da TurnContext utilizzando l'helper fromTurnContext nel pacchetto @microsoft/agents-a365-observability-hosting. Questo helper estrae automaticamente il chiamante, l'agente, il tenant, il canale e i dettagli della conversazione dall'attività.

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.

È possibile popolare automaticamente il BaggageBuilder dal ITurnContext usando il metodo di estensione FromTurnContext nel pacchetto Microsoft.Agents.A365.Observability.Hosting. Questo metodo estrae automaticamente il chiamante, l'agente, il tenant, il canale e i dettagli della conversazione dall'attività.

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

Per lo scenario di lavoro digitale, se l'agente usa il pacchetto Microsoft Agent 365 Observability Hosting Library, usare AgenticTokenCache per gestire automaticamente la memorizzazione nella cache dei token. Registrare il token una volta per agente e tenant durante un gestore di attività e passare cache.get_observability_token come token_resolver nella configurazione di osservabilità.

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

Per lo scenario del lavoratore digitale, se il tuo agente usa il pacchetto @microsoft/agents-a365-observability-hosting, usa AgenticTokenCacheInstance per gestire automaticamente la memorizzazione nella cache dei token. Chiamare RefreshObservabilityToken una volta per agente e tenant durante un gestore attività e passare AgenticTokenCacheInstance.getObservabilityToken come tokenResolver nella configurazione di osservabilità.

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

Fornire un resolver di token eseguendo la registrazione Agent365ExporterOptions con un TokenResolver delegato. Il delegato riceve agentId e tenantId restituisce un token di autenticazione.

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

Per lo scenario di lavoro digitale, se l'agente usa il Microsoft.Agents.A365.Observability.Hosting NuGet package, usa il metodo AddAgenticTracingExporter() per gestire automaticamente il caching dei token tramite dependency injection.

using Microsoft.Agents.A365.Observability.Hosting;

builder.Services.AddAgenticTracingExporter();

Nell'applicazione dell'agente, registra il token.

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

Installare il pacchetto .

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

Configura l'osservabilità.

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

Kernel semantico non è supportato con JavaScript.

Aggiungi dipendenze alla raccolta di servizi.

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

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

Imposta AgentId e TenantId usando BaggageBuilder. Assicurati che l'ID che usi per creare un ChatCompletionAgent corrisponda all'ID dell'agente che passi a BaggageBuilder.

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>,
          ...
      };
    }
}

Installare il pacchetto .

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

Configura l'osservabilità.

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

Installare il pacchetto .

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

Configura l'osservabilità.

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

Aggiungi dipendenze alla raccolta di servizi.

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

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

Imposta AgentId e TenantId usando BaggageBuilder. Per le chiamate agli strumenti, avvia una traccia usando Trace() in un'istanza ChatToolCall.

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

Installare il pacchetto .

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

Configura l'osservabilità.

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 non è supportato con JavaScript.

Aggiungi dipendenze alla raccolta di servizi.

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

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

Imposta AgentId e TenantId usando 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();
    }
}

Installare il pacchetto .

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

Configura l'osservabilità.

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

Installare il pacchetto .

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

Configura l'osservabilità.

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 non è supportato con .NET.

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

Se l'agente usa il @microsoft/agents-a365-observability-hosting pacchetto, è possibile usare ScopeUtils.populateInvokeAgentScopeFromTurnContext per creare l'ambito con i dettagli dell'agente, i dettagli del chiamante e le informazioni sul canale derivate automaticamente da TurnContext.

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

Se l'agente utilizza il pacchetto @microsoft/agents-a365-observability-hosting, usare ScopeUtils.populateExecuteToolScopeFromTurnContext per creare l'ambito con i dettagli dell'agente derivati automaticamente dal TurnContext.

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

Se il tuo agente utilizza il pacchetto @microsoft/agents-a365-observability-hosting, puoi usare ScopeUtils.populateInferenceScopeFromTurnContext per creare lo scopo con i dettagli dell'agente derivati automaticamente da TurnContext.

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

Impostare la variabile di ambiente ENABLE_A365_OBSERVABILITY_EXPORTER su false. Questa impostazione si estende (traccia) nella console.

Impostare la variabile di ambiente ENABLE_A365_OBSERVABILITY_EXPORTER su false. Questa impostazione si estende (traccia) nella console.

Impostare EnableAgent365Exporter su false in appsettings.json. Questa impostazione esporta gli intervalli (tracce) sulla console.

• Le proprietà impostate usando la classe BaggageBuilder potrebbero essere impostate o sovrascritte dalle proprietà dei rispettivi ambiti.

• Imposta le proprietà nella tabella seguente usando il metodo InvokeAgentScope.start.

  Data	Descrizione
  invoke_agent_details.details.agent_id	Identificatore univoco per l'agente di intelligenza artificiale
  invoke_agent_details.details.agent_name	Nome leggibile dell'agente di intelligenza artificiale
  invoke_agent_details.details.agent_auid	ID utente agente (AUID)
  invoke_agent_details.details.agent_upn	Nome dell'entità utente dell'agente (UPN)
  invoke_agent_details.details.agent_blueprint_id	ID applicazione/blueprint dell'agente
  invoke_agent_details.details.tenant_id	ID tenant per l'agente
  invoke_agent_details.details.conversation_id	Identificatore della conversazione o della sessione
  invoke_agent_details.endpoint	Endpoint per la chiamata dell'agente
  tenant_details.tenant_id	Identificatore univoco per il tenant
  request.content	Il contenuto del payload inviato all'agente per l'invocazione
  request.execution_type	Tipo di invocazione che indica l'origine della richiesta (ad esempio, HumanToAgent o AgentToAgent)
  caller_details.caller_id	Identificatore univoco per il chiamante
  caller_details.caller_upn	Nome principale utente (UPN) del chiamante
  caller_details.caller_user_id	ID utente del chiamante
  caller_details.tenant_id	ID tenant del chiamante

• Imposta le proprietà nella tabella seguente utilizzando il metodo ExecuteToolScope.start.

  Data	Descrizione
  details.tool_name	Nome dello strumento da eseguire
  details.arguments	Argomenti o parametri degli strumenti
  details.tool_call_id	Identificatore univoco per la chiamata allo strumento
  details.tool_type	Tipo dello strumento in esecuzione
  details.endpoint	Se viene effettuata una chiamata di uno strumento esterno
  agent_details.agent_id	Identificatore univoco per l'agente di intelligenza artificiale
  agent_details.agent_name	Nome leggibile dell'agente di intelligenza artificiale
  agent_details.agent_auid	L'ID utente dell'agente
  agent_details.agent_upn	Nome dell'entità utente dell'agente (UPN)
  agent_details.agent_blueprint_id	Il schema dell'agente o l'ID applicazione
  agent_details.tenant_id	ID tenant per l'agente.
  agent_details.conversation_id	ID della conversazione per la chiamata dell'agente.
  tenant_details.tenant_id	ID tenant per l'agente.

• Imposta le proprietà nella tabella seguente utilizzando il metodo InferenceScope.start.

  Data	Descrizione
  details.operationName	Il nome o tipo dell'operazione per l'inferenza
  details.model	Il nome o l'identificatore del modello
  details.providerName	Il nome del fornitore
  agent_details.agent_id	Identificatore univoco per l'agente di intelligenza artificiale
  agent_details.agent_name	Nome leggibile dell'agente di intelligenza artificiale
  agent_details.agent_auid	ID utente agente (AUID)
  agent_details.agent_upn	Nome dell'entità utente dell'agente (UPN)
  agent_details.agent_blueprint_id	Il schema dell'agente o l'ID applicazione
  agent_details.tenant_id	Identificatore univoco per il tenant
  agent_details.conversation_id	Identificatore della conversazione o della sessione
  tenant_details.tenant_id	Identificatore univoco per il tenant
  request.content	Il contenuto del payload inviato all'agente per effettuare l'inferenza
  request.execution_type	Tipo di invocazione che indica l'origine della richiesta (ad esempio, HumanToAgent o AgentToAgent)
  request.source_metadata	Rappresenta le informazioni sul canale

• Le proprietà che si impostano usando la classe BaggageBuilder potrebbero essere impostate o sovrascritte dalle proprietà dei rispettivi ambiti.

• Imposta le proprietà nella tabella seguente usando il metodo InvokeAgentScope.start.

  Data	Descrizione
  agentDetails.agentId	Identificatore univoco per l'agente di intelligenza artificiale
  agentDetails.agentName	Nome leggibile dell'agente di intelligenza artificiale
  agentDetails.agentAuid	ID utente agente (AUID)
  agentDetails.agentEmail	Indirizzo di posta elettronica dell'agente
  agentDetails.agentBlueprintId	ID applicazione/blueprint dell'agente
  agentDetails.tenantId	ID tenant per l'agente
  scopeDetails.endpoint.host	L'indirizzo host dell'endpoint per l'invocazione dell'agente
  scopeDetails.endpoint.port	Numero di porta dell'endpoint per la chiamata dell'agente
  request.content	Il contenuto del payload della richiesta per l'invocazione dell'agente
  request.conversationId	Identificatore della conversazione o della sessione
  request.sessionId	L'ID della sessione per l'invocazione dell'agente
  request.channel.name	Canalizza informazioni come (msteams, email, e così via)
  callerDetails.userDetails.userId	Identificatore univoco per il chiamante
  callerDetails.userDetails.userName	Nome visualizzato del chiamante
  callerDetails.userDetails.userEmail	Indirizzo di posta elettronica del chiamante

• Imposta le proprietà nella tabella seguente utilizzando il metodo ExecuteToolScope.start.

  Data	Descrizione
  details.toolName	Nome dello strumento da eseguire
  details.arguments	Argomenti o parametri degli strumenti
  details.toolCallId	Identificatore univoco per la chiamata allo strumento
  details.toolType	Tipo dello strumento in esecuzione
  details.endpoint.host	L'indirizzo host dell'endpoint per l'esecuzione dello strumento. Richiesto se viene effettuata una chiamata esterna
  details.endpoint.port	Il numero di porta dell'endpoint per l'esecuzione dello strumento. Richiesto se viene effettuata una chiamata esterna
  agentDetails.agentId	Identificatore univoco per l'agente di intelligenza artificiale
  agentDetails.agentName	Nome leggibile dell'agente di intelligenza artificiale
  agentDetails.tenantId	ID tenant per l'agente
  request.conversationId	Identificatore della conversazione o della sessione

• Imposta le proprietà nella tabella seguente utilizzando il metodo InferenceScope.start.

  Data	Descrizione
  details.operationName	Il nome o tipo dell'operazione per l'inferenza
  details.model	Il nome o l'identificatore del modello
  details.providerName	Il nome del fornitore
  agentDetails.agentId	Identificatore univoco per l'agente di intelligenza artificiale
  agentDetails.agentName	Nome leggibile dell'agente di intelligenza artificiale
  agentDetails.tenantId	ID tenant per l'agente
  request.conversationId	Identificatore della conversazione o della sessione

• Le proprietà che si impostano usando la classe BaggageBuilder potrebbero essere impostate o sovrascritte dalle proprietà dei rispettivi ambiti.

• Imposta le proprietà nella tabella seguente utilizzando il metodo InvokeAgentScope.Start.

  Data	Descrizione
  invokeAgentDetails.details.agentId	Identificatore univoco dell'agente.
  invokeAgentDetails.details.agentName	Mostra il nome dell'agente.
  invokeAgentDetails.details.agentAUID	Azure ID utente (AUID) per l'agente.
  invokeAgentDetails.details.agentUPN	Nome Utente Principale (UPN) dell'agente.
  invokeAgentDetails.details.agentBlueprintId	ID applicazione/blueprint per l'agente.
  invokeAgentDetails.details.tenantId	ID tenant per l'agente.
  invokeAgentDetails.endpoint	URI endpoint dell'agente da invocare.
  tenantDetails.tenantId	L'identificatore dell'inquilino.
  request.content	Il contenuto del payload fornito all'agente.
  request.executionType	Tipo di esecuzione che descrive la richiesta.
  request.sourceMetadata.name	Nome leggibile della fonte. Nome del canale.
  conversationId	ID della conversazione per la chiamata dell'agente.

• Imposta le proprietà nella tabella seguente usando il metodo ExecuteToolScope.Start.

  Data	Descrizione
  details.toolName	Nome dello strumento che viene invocato.
  details.arguments	Gli argomenti serializzati vengono passati allo strumento.
  details.toolCallId	Identificatore per l'invocazione dello strumento.
  details.toolType	Classificazione dei tipi per lo strumento.
  details.endpoint	Endpoint richiesto per l'esecuzione remota degli strumenti.
  agentDetails.agentId	Identificatore univoco dell'agente.
  agentDetails.agentName	Mostra il nome dell'agente.
  agentDetails.agentAUID	Azure ID utente (AUID) per l'agente.
  agentDetails.agentUPN	Nome Utente Principale (UPN) dell'agente.
  agentDetails.agentBlueprintId	ID applicazione/blueprint per l'agente.
  agentDetails.tenantId	ID tenant per l'agente.
  tenantDetails.tenantId	L'identificatore dell'inquilino.

• Imposta le proprietà nella tabella seguente usando il metodo InferenceScope.Start.

  Data	Descrizione
  details.operationName	Identificatore di telemetria per l'operazione di inferenza.
  details.model	Nome del modello utilizzato per soddisfare la richiesta di inferenza.
  details.providerName	Il fornitore responsabile della chiamata di inferenza.
  agentDetails.agentId	Identificatore univoco dell'agente.
  agentDetails.agentName	Mostra il nome dell'agente.
  agentDetails.agentAUID	Azure ID utente (AUID) per l'agente.
  agentDetails.agentUPN	Nome Utente Principale (UPN) dell'agente.
  agentDetails.agentBlueprintId	ID applicazione/blueprint per l'agente.
  agentDetails.tenantId	ID tenant per l'agente.
  tenantDetails.tenantId	L'identificatore dell'inquilino.
  parentId	Per una gestione esplicita dell'ambito genitore. Non è obbligatorio nella maggior parte dei casi.