Osservabilità dell'agente

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

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

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

Imposta le variabili ambientali per l'osservabilità:

from microsoft_agents_a365.observability.core import config

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

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

Il risolver dei token è escluso dal login alla console.

Imposta le variabili ambientali per l'osservabilità:

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

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

Impostare EnableAgent365Exporter su true in appsettings.json.

In Program.csaggiungi Agent365ExporterOptions alla raccolta di servizi. Questa modifica configura il delegato usato dall'utilità di esportazione della traccia per recuperare il token.

Aggiungi dipendenze legate all'osservabilità usando AddA365Tracing().

using Microsoft.Agents.A365.Observability.Runtime;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton(sp =>
    {
        return new Agent365ExporterOptions
        {
            ClusterCategory = "prod",
            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();

from microsoft_agents_a365.observability.core.middleware.baggage_builder import BaggageBuilder

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

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

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

// Execute operations within the baggage context
baggageScope.run(() => {
  // All spans created within this context will inherit the baggage values
  
  // Invoke another agent
  using agentScope = InvokeAgentScope.start(invokeDetails, agentDetails, tenantDetails);
  // ... agent logic
  
  // Execute tools
  using toolScope = ExecuteToolScope.start(toolDetails, agentDetails, tenantDetails);
  // ... tool logic
});

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

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.environment_utils 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

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

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

const downloader = new AttachmentDownloader();

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

Aggiungi lo strumento di risoluzione del token agentico alla raccolta di servizi.

using Microsoft.Agents.A365.Observability;

builder.Services.AddAgenticTracingExporter();

Nell'applicazione dell'agente registra il token.

using Microsoft.Agents.Builder;
using Microsoft.Agents.Core.Models;
using Microsoft.Extensions.Logging;
using Microsoft.Agents.A365.Observability.Caching;
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
                },
                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.config import configure
from microsoft_agents_a365.observability.extensions.semantic_kernel 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

Il kernel semantico non è supportato con JavaScript.

Aggiungi dipendenze alla raccolta di servizi.

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

builder.Services.AddTracing(config => config.WithSemanticKernel());

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

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.config import configure
from microsoft_agents_a365.observability.extensions.openai_agents 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')
    .withConsoleExporter(true)
);

// 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.Services.AddTracing(config => config.WithOpenAI());

Imposta AgentId e TenantId usando BaggageBuilder. Per le chiamate di strumenti, avvia una traccia usando Trace() su 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.config import configure
from microsoft_agents_a365.observability.extensions.agentframework.trace_instrumentor 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.Services.AddTracing(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();
    }
}

from microsoft_agents_a365.observability.core.invoke_agent_scope import InvokeAgentScope
from microsoft_agents_a365.observability.core.invoke_agent_details import InvokeAgentDetails
from microsoft_agents_a365.observability.core.tenant_details import TenantDetails
from microsoft_agents_a365.observability.core.request import Request

invoke_details = InvokeAgentDetails(
    details=agent_details,        # AgentDetails instance
    endpoint=my_endpoint,         # Optional endpoint (with hostname/port)
    session_id="session-42"
)
tenant_details = TenantDetails(tenant_id="tenant-123")
req = Request(content="User asks a question")

with InvokeAgentScope.start(invoke_details, tenant_details, req):
    # Perform agent invocation logic
    response = call_agent(...)

import { 
  InvokeAgentScope, 
  ExecutionType, 
  CallerDetails, 
  EnhancedAgentDetails 
} from '@microsoft/agents-a365-observability';

// Basic agent invocation details
const invokeDetails = {
  agentId: 'email-agent-123',
  agentName: 'Email Assistant',
  ...
  }
};

const tenantDetails = {
  tenantId: 'tenant-789'
};

// Optional: Caller details (human user)
const callerDetails: CallerDetails = {};

// Optional: Caller agent details (for agent-to-agent calls)
const callerAgentDetails: EnhancedAgentDetails = {};

// Enhanced invocation with caller context
using scope = InvokeAgentScope.start(
  invokeDetails,
  tenantDetails,
  callerAgentDetails,
  callerDetails
);

try {
  // Record input messages
  scope.recordInputMessages(['Please help me organize my emails', 'Focus on urgent items']);
  
  // Your agent invocation logic here
  const response = await invokeAgent(invokeDetails.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;
}
// Scope automatically disposed at end of using block

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: Guid.NewGuid().ToString(),
            agentName: "MyAgent",
            agentDescription: "Handles user requests.",
            tenantId: "tenant-789"
        );

        var tenantDetails = new TenantDetails(Guid.Parse("11111111-2222-3333-4444-555555555555"));

        var request = new Request(
            content: userInput,
            executionType: ExecutionType.HumanToAgent,
            sessionId: "session-abc",
            channelMetadata: new ChannelMetadata("webchat", "https://webchat.contoso.com")
        );

        var callerDetails = new CallerDetails(
            callerId: "user-123",
            callerName: "Jane Doe",
            callerUpn: "jane.doe@contoso.com",
            callerUserId: "user-uuid-456",
            tenantId: "tenant-789"
        );

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

        var invokeAgentDetails = new InvokeAgentDetails(endpoint, agentDetails, sessionId: "session-abc");

        var conversationId = "conv-xyz";

        // Start the scope
        using var scope = InvokeAgentScope.Start(
            invokeAgentDetails: invokeAgentDetails,
            tenantDetails: tenantDetails,
            request: request,
            callerAgentDetails: null,
            callerDetails: callerDetails,
            conversationId: conversationId
        );

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

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

        // Simulate agent processing and output
        var output = $"Processed: {userInput}";
        scope.RecordOutputMessages(new[] { output });

        // Optionally record a single response
        scope.RecordResponse(output);

        return new AgentResponse { Content = output };
    }
}

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

from microsoft_agents_a365.observability.core.execute_tool_scope import ExecuteToolScope
from microsoft_agents_a365.observability.core.tool_call_details import ToolCallDetails

tool_details = ToolCallDetails(
    tool_name="summarize",
    tool_type="function",
    tool_call_id="tc-001",
    arguments="{'text': '...'}",
    description="Summarize provided text",
    endpoint=None  # or endpoint object with hostname/port
)

with ExecuteToolScope.start(tool_details, agent_details, tenant_details):
    result = run_tool(tool_details)

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

const toolDetails = {
  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'
  }
};

using scope = ExecuteToolScope.start(toolDetails, agentDetails, tenantDetails);

try {
  // Execute the tool
  const result = await searchEmails(toolDetails.arguments);
  
  // Record the tool execution result
  scope.recordResponse(JSON.stringify(result));
  
  return result;
} catch (error) {
  scope.recordError(error as Error);
  throw error;
}

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

public class MyToolAgent
{
    public async Task<ToolResult> ExecuteTool(string toolName, object parameters)
    {
        var agentDetails = new AgentDetails(
            agentId: Guid.NewGuid().ToString(),
            agentName: "ToolAgent",
            agentDescription: "Executes tools for users.",
            agentAUID: "tool-auid-123",
            agentUPN: "toolagent@contoso.com",
            agentBlueprintId: "tool-blueprint-456",
            agentType: AgentType.EntraEmbodied,
            tenantId: "tenant-789"
        );

        var tenantDetails = new TenantDetails(Guid.Parse("11111111-2222-3333-4444-555555555555"));

        var endpoint = new Uri("https://toolagent.contoso.com:8443");

        var toolCallDetails = new ToolCallDetails(
            toolName: toolName,
            arguments: System.Text.Json.JsonSerializer.Serialize(parameters),
            toolCallId: Guid.NewGuid().ToString(),
            description: "Runs a tool operation.",
            toolType: "custom-type",
            endpoint: endpoint
        );

        // Start the scope
        using var scope = ExecuteToolScope.Start(
            toolCallDetails: toolCallDetails,
            agentDetails: agentDetails,
            tenantDetails: tenantDetails
        );

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

        // Record response
        var toolOutput = $"Tool '{toolName}' processed with parameters: {System.Text.Json.JsonSerializer.Serialize(parameters)}";
        scope.RecordResponse(toolOutput);

        return new ToolResult { Output = toolOutput };
    }
}

public class ToolResult
{
    public string Output { get; set; }
}

from microsoft_agents_a365.observability.core.inference_scope import InferenceScope
from microsoft_agents_a365.observability.core.inference_call_details import InferenceCallDetails
from microsoft_agents_a365.observability.core.request import Request

inference_details = InferenceCallDetails(
    operationName=SomeEnumOrValue("chat"),
    model="gpt-4o-mini",
    providerName="azure-openai",
    inputTokens=123,
    outputTokens=456,
    finishReasons=["stop"],
    responseId="resp-987"
)
req = Request(content="Explain quantum computing simply.")

with InferenceScope.start(inference_details, agent_details, tenant_details, req):
    completion = call_llm(...)

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

const inferenceDetails = {
  operationName: InferenceOperationType.CHAT,
  model: 'gpt-4',
  providerName: 'openai',
  inputTokens: 150,
  outputTokens: 75,
  finishReasons: ['stop'],
  responseId: 'resp-123456'
};

using scope = InferenceScope.start(inferenceDetails, agentDetails, tenantDetails);

try {
  // 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);  // Update if different from constructor
  scope.recordOutputTokens(82);  // Update if different from constructor
  scope.recordResponseId('resp-789123');
  scope.recordFinishReasons(['stop', 'max_tokens']);
  
  return response.text;
} catch (error) {
  scope.recordError(error as Error);
  throw error;
}

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

public class MyInferenceAgent
{
    public async Task<InferenceResult> RunInference(string input)
    {
        var agentDetails = new AgentDetails(
            agentId: Guid.NewGuid().ToString(),
            agentName: "InferenceAgent",
            agentDescription: "Performs generative AI inference.",
            agentAUID: "inference-auid-123",
            agentUPN: "inferenceagent@contoso.com",
            agentBlueprintId: "inference-blueprint-456",
            agentType: AgentType.EntraEmbodied,
            tenantId: "tenant-789"
        );

        var tenantDetails = new TenantDetails(Guid.Parse("11111111-2222-3333-4444-555555555555"));

        var inferenceDetails = new InferenceCallDetails(
            operationName: InferenceOperationType.Chat,
            model: "gpt-4",
            providerName: "OpenAI",
            inputTokens: 42,
            outputTokens: 84,
            finishReasons: new[] { "stop", "length" },
            responseId: "response-xyz"
        );

        // Start the scope
        using var scope = InferenceScope.Start(
            details: inferenceDetails,
            agentDetails: agentDetails,
            tenantDetails: tenantDetails
        );

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

        // Record input/output messages and other telemetry
        scope.RecordInputMessages(new[] { input, "additional context" });
        scope.RecordOutputMessages(new[] { "AI response message" });
        scope.RecordInputTokens(42);
        scope.RecordOutputTokens(84);
        scope.RecordResponseId("response-xyz");
        scope.RecordFinishReasons(new[] { "stop", "length" });
        scope.RecordThoughtProcess("Reasoning step 1; step 2");

        return new InferenceResult { Output = "AI response message" };
    }
}

public class InferenceResult
{
    public string Output { get; set; }
}

Impostare la variabile di ambiente ENABLE_A365_OBSERVABILITY_EXPORTER su false. Questa impostazione esporta le span (tracce) sulla console.

Impostare la variabile di ambiente ENABLE_A365_OBSERVABILITY_EXPORTER su false. Questa impostazione esporta le span (tracce) sulla console.

Impostare EnableAgent365Exporter su false in appsettings.json. Questa impostazione esporta le span (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 progetto/applicazione 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 dell'entità 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 progetto dell'agente o l'ID applicazione
  agent_details.tenant_id	ID inquilino per l'agente.
  agent_details.conversation_id	L'ID della conversazione per l'invocazione dell'agente.
  tenant_details.tenant_id	ID inquilino 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 progetto 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 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
  invokeAgentDetails.agentAUID	ID utente agente (AUID)
  invokeAgentDetails.agentBlueprintId	ID progetto/applicazione dell'agente
  invokeAgentDetails.agentId	Identificatore univoco per l'agente di intelligenza artificiale
  invokeAgentDetails.agentName	Nome leggibile dell'agente di intelligenza artificiale
  invokeAgentDetails.agentUPN	Nome dell'entità utente dell'agente (UPN)
  invokeAgentDetails.conversationId	Identificatore della conversazione o della sessione
  invokeAgentDetails.endpoint.host	L'indirizzo host dell'endpoint per l'invocazione dell'agente
  invokeAgentDetails.endpoint.port	Il numero di porta dell'endpoint per l'invocazione dell'agente
  invokeAgentDetails.endpoint.protocol	L'endpoint del protocollo per l'invocazione dell'agente
  invokeAgentDetails.request.content	Il contenuto del payload della richiesta per l'invocazione dell'agente
  invokeAgentDetails.request.executionType	Il tipo di invocazione del payload di richiesta per l'invocazione dell'agente
  invokeAgentDetails.request.sourceMetadata.name	Canalizza informazioni come (msteams, email, e così via)
  invokeAgentDetails.tenantId	ID tenant per l'agente
  tenantDetails.tenantId	Identificatore univoco per il tenant
  callerDetails.callerId	L'identificatore univoco per il chiamante (aadObjectId)
  callerDetails.callerName	Nome visualizzato del chiamante
  callerDetails.callerUpn	Nome dell'entità utente (UPN) del chiamante
  callerDetails.tenantId	ID tenant del chiamante

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

  Data	Descrizione
  details.arguments	Argomenti o parametri degli strumenti
  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
  details.endpoint.protocol	Il protocollo dell'endpoint per l'esecuzione dello strumento. Richiesto se viene effettuata una chiamata esterna
  details.toolCallId	Identificatore univoco per la chiamata allo strumento
  details.toolName	Nome dello strumento da eseguire
  details.toolType	Tipo dello strumento in esecuzione
  agentDetails.agentId	Identificatore univoco per l'agente di intelligenza artificiale
  agentDetails.agentName	Nome leggibile dell'agente di intelligenza artificiale
  agentDetails.conversationId	Identificatore della conversazione o della sessione
  tenantDetails.tenantId	Identificatore univoco per il tenant

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

  Data	Descrizione
  details.model	Il nome o l'identificatore del modello
  details.operationName	Il nome o tipo dell'operazione per l'inferenza
  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.conversationId	Identificatore della conversazione o della sessione
  tenantDetails.tenantId	Identificatore univoco per il tenant

• 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 User ID (AUID) per l'agente.
  invokeAgentDetails.details.agentUPN	Nome Principale Utente (UPN) per l'agente.
  invokeAgentDetails.details.agentBlueprintId	Progetto o ID della domanda per l'agente.
  invokeAgentDetails.details.tenantId	ID inquilino 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 per l'uomo della fonte. Nome del canale.
  conversationId	L'ID della conversazione per l'invocazione 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 passavano 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 User ID (AUID) per l'agente.
  agentDetails.agentUPN	Nome Principale Utente (UPN) per l'agente.
  agentDetails.agentBlueprintId	Progetto o ID della domanda per l'agente.
  agentDetails.tenantId	ID inquilino 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 User ID (AUID) per l'agente.
  agentDetails.agentUPN	Nome Principale Utente (UPN) per l'agente.
  agentDetails.agentBlueprintId	Progetto o ID della domanda per l'agente.
  agentDetails.tenantId	ID inquilino per l'agente.
  tenantDetails.tenantId	L'identificatore dell'inquilino.
  parentId	Per una gestione esplicita dell'ambito genitore. Non è obbligatorio nella maggior parte dei casi.