Agentes de observabilidade

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

As variáveis do ambiente necessárias para a observabilidade são:

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

Exclua o resolvedor de token para logar no console.

As variáveis do ambiente necessárias para a observabilidade são:

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

Definir EnableAgent365Exporter como true em appsettings.json.

No Program.cs, chame Agent365ExporterOptions na coleção de serviços. Essa alteração configura o delegado que o exportador de rastreamento usa para recuperar o token.

Adicione dependências relacionadas à observabilidade 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
  };

Adicione o resolvedor de tokens agentes à sua coleção de serviços.

using Microsoft.Agents.A365.Observability;

builder.Services.AddAgenticTracingExporter();

No aplicativo do agente, registre o 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}");
        }
    }
}

Instalar o pacote

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

Configurar a observabilidade

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

Semantic Kernel não é suportado com JavaScript.

Adicione dependências à coleção de serviços.

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

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

Defina AgentId e TenantId use BaggageBuilder. Certifique-se de que o ID usado ao criar um ChatCompletionAgent corresponda ao ID do agente passado para 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>,
          ...
      };
    }
}

Instale o pacote.

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

Configurar a observabilidade

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

Instalar o pacote

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

Configurar a observabilidade

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

Adicione dependências à coleção de serviços.

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

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

Defina AgentId e TenantId use BaggageBuilder. Para chamadas de ferramenta, inicie um rastreamento usando Trace() em uma ChatToolCall instância.

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

Instalar o pacote

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

Configurar a observabilidade

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

O Agent Framework não é suportado com JavaScript.

Adicione dependências à coleção de serviços.

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

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

Defina AgentId e TenantId use 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; }
}

Defina a variável de ambiente ENABLE_A365_OBSERVABILITY_EXPORTER como false. Isso exporta os spans (traces) para o console.

Defina a variável de ambiente ENABLE_A365_OBSERVABILITY_EXPORTER como false. Isso exporta os spans (traces) para o console.

Definir EnableAgent365Exporter como false em appsettings.json. Isso exporta os spans (traces) para o console.

• Propriedades definidas usando a classe BaggageBuilder podem ser definidas ou sobrescrevidas pelas propriedades dos respectivos escopos.

• Defina as propriedades na tabela a seguir usando o método InvokeAgentScope.start.

  Dados	Description
  invoke_agent_details.details.agent_id	O identificador exclusivo para o agente de IA
  invoke_agent_details.details.agent_name	O nome legível pelo ser humano do agente de IA
  invoke_agent_details.details.agent_auid	A ID do usuário do agente (AUID)
  invoke_agent_details.details.agent_upn	O nome da entidade de usuário do agente (UPN)
  invoke_agent_details.details.agent_blueprint_id	A ID do blueprint/aplicativo do agente
  invoke_agent_details.details.tenant_id	A ID do locatário do agente
  invoke_agent_details.details.conversation_id	O identificador da conversa ou sessão
  invoke_agent_details.endpoint	O ponto de extremidade para a invocação do agente
  tenant_details.tenant_id	O identificador exclusivo para o locatário
  request.content	O conteúdo da carga útil enviado ao agente para invocação
  request.execution_type	Tipo de invocação indicando a origem da solicitação (por exemplo, HumanToAgent ou AgentToAgent)
  caller_details.caller_id	O identificador exclusivo para o chamador
  caller_details.caller_upn	O UPN (nome da entidade de usuário) do chamador
  caller_details.caller_user_id	A ID do usuário do chamador
  caller_details.tenant_id	A ID do locatário do chamador

• Defina as propriedades na tabela seguinte usando o método ExecuteToolScope.start.

  Dados	Description
  details.tool_name	O nome da ferramenta que está sendo executada
  details.arguments	Argumentos/parâmetros da ferramenta
  details.tool_call_id	O identificador exclusivo para a chamada de ferramenta
  details.tool_type	O tipo da ferramenta que está sendo executada
  details.endpoint	Se uma chamada de ferramenta externa for feita
  agent_details.agent_id	O identificador exclusivo para o agente de IA
  agent_details.agent_name	O nome legível pelo ser humano do agente de IA
  agent_details.agent_auid	O ID de usuário do agente
  agent_details.agent_upn	O nome da entidade de usuário do agente (UPN)
  agent_details.agent_blueprint_id	A ID do blueprint/aplicativo do agente
  agent_details.tenant_id	ID de inquilino do corretor.
  agent_details.conversation_id	O ID da conversa para a invocação do agente.
  tenant_details.tenant_id	ID de inquilino do corretor.

• Defina as propriedades na tabela a seguir usando o método InferenceScope.start.

  Dados	Description
  details.operationName	O nome/tipo da operação para a inferência
  details.model	O nome/identificador do modelo
  details.providerName	Nome do provedor
  agent_details.agent_id	O identificador exclusivo para o agente de IA
  agent_details.agent_name	O nome legível pelo ser humano do agente de IA
  agent_details.agent_auid	A ID do usuário do agente (AUID)
  agent_details.agent_upn	O nome da entidade de usuário do agente (UPN)
  agent_details.agent_blueprint_id	A ID do blueprint/aplicativo do agente
  agent_details.tenant_id	O identificador exclusivo para o locatário
  agent_details.conversation_id	O identificador da conversa ou sessão
  tenant_details.tenant_id	O identificador exclusivo para o locatário
  request.content	O conteúdo da carga útil enviado ao agente para inferência
  request.execution_type	Tipo de invocação indicando a origem da solicitação (por exemplo, HumanToAgent ou AgentToAgent)
  request.source_metadata	Represente as informações do canal

• Propriedades definidas usando a classe BaggageBuilder podem ser definidas ou sobrescrevidas pelas propriedades dos respectivos escopos.

• Defina as propriedades na tabela a seguir usando o método InvokeAgentScope.start.

  Dados	Description
  invokeAgentDetails.agentAUID	A ID do usuário do agente (AUID)
  invokeAgentDetails.agentBlueprintId	A ID do blueprint/aplicativo do agente
  invokeAgentDetails.agentId	O identificador exclusivo para o agente de IA
  invokeAgentDetails.agentName	O nome legível pelo ser humano do agente de IA
  invokeAgentDetails.agentUPN	O nome da entidade de usuário do agente (UPN)
  invokeAgentDetails.conversationId	O identificador da conversa ou sessão
  invokeAgentDetails.endpoint.host	O endereço do host do endpoint para a invocação do agente
  invokeAgentDetails.endpoint.port	O número da porta do endpoint para a invocação do agente
  invokeAgentDetails.endpoint.protocol	O ponto final do protocolo para a invocação do agente
  invokeAgentDetails.request.content	O conteúdo da carga útil de requisição para a invocação do agente
  invokeAgentDetails.request.executionType	O tipo de invocação da carga útil de requisição para a invocação do agente
  invokeAgentDetails.request.sourceMetadata.name	Canalize informações como (msteams, email, e assim por diante)
  invokeAgentDetails.tenantId	A ID do locatário do agente
  tenantDetails.tenantId	O identificador exclusivo para o locatário
  callerDetails.callerId	O identificador único para o chamador (aadObjectId)
  callerDetails.callerName	O nome de exibição do chamador
  callerDetails.callerUpn	O UPN (nome da entidade de usuário) do chamador
  callerDetails.tenantId	A ID do locatário do chamador

• Defina as propriedades na tabela seguinte usando o método ExecuteToolScope.start.

  Dados	Description
  details.arguments	Argumentos/parâmetros da ferramenta
  details.endpoint.host	O endereço host do endpoint para a execução da ferramenta. É obrigatório se for feita uma chamada externa
  details.endpoint.port	O número da porta do endpoint para a execução da ferramenta. É obrigatório se for feita uma chamada externa
  details.endpoint.protocol	O protocolo do endpoint para a execução da ferramenta. É obrigatório se for feita uma chamada externa
  details.toolCallId	O identificador exclusivo para a chamada de ferramenta
  details.toolName	O nome da ferramenta que está sendo executada
  details.toolType	O tipo da ferramenta que está sendo executada
  agentDetails.agentId	O identificador exclusivo para o agente de IA
  agentDetails.agentName	O nome legível pelo ser humano do agente de IA
  agentDetails.conversationId	O identificador da conversa ou sessão
  tenantDetails.tenantId	O identificador exclusivo para o locatário

• Defina as propriedades na tabela a seguir usando o método InferenceScope.start.

  Dados	Description
  details.model	O nome/identificador do modelo
  details.operationName	O nome/tipo da operação para a inferência
  details.providerName	Nome do provedor
  agentDetails.agentId	O identificador exclusivo para o agente de IA
  agentDetails.agentName	O nome legível pelo ser humano do agente de IA
  agentDetails.conversationId	O identificador da conversa ou sessão
  tenantDetails.tenantId	O identificador exclusivo para o locatário

• Propriedades definidas usando a classe BaggageBuilder podem ser definidas ou sobrescrevidas pelas propriedades dos respectivos escopos.

• Defina as propriedades na tabela a seguir usando o método InvokeAgentScope.Start.

  Dados	Description
  invokeAgentDetails.details.agentId	O identificador exclusivo do agente.
  invokeAgentDetails.details.agentName	Nome de exibição do agente.
  invokeAgentDetails.details.agentAUID	Azure User ID (AUID) para o agente.
  invokeAgentDetails.details.agentUPN	Nome Principal do Usuário (UPN) para o agente.
  invokeAgentDetails.details.agentBlueprintId	Projeto/ID de aplicação para o agente.
  invokeAgentDetails.details.tenantId	ID de inquilino do corretor.
  invokeAgentDetails.endpoint	URI do endpoint do agente a ser invocado.
  tenantDetails.tenantId	O identificador do inquilino.
  request.content	O conteúdo da carga útil fornecido ao agente.
  request.executionType	Tipo de execução que descreve a solicitação.
  request.sourceMetadata.name	Nome legível para humanos da fonte. Nome do canal.
  conversationId	O ID da conversa para a invocação do agente.

• Defina as propriedades na tabela a seguir usando o método ExecuteToolScope.Start.

  Dados	Description
  details.toolName	Nome da ferramenta que está sendo invocada.
  details.arguments	Argumentos serializados eram passados para a ferramenta.
  details.toolCallId	Identificador para a invocação da ferramenta.
  details.toolType	Classificação de tipos para a ferramenta.
  details.endpoint	Endpoint necessário para execução remota de ferramentas.
  agentDetails.agentId	O identificador exclusivo do agente.
  agentDetails.agentName	Nome de exibição do agente.
  agentDetails.agentAUID	Azure User ID (AUID) para o agente.
  agentDetails.agentUPN	Nome Principal do Usuário (UPN) para o agente.
  agentDetails.agentBlueprintId	Projeto/ID de aplicação para o agente.
  agentDetails.tenantId	ID de inquilino do corretor.
  tenantDetails.tenantId	O identificador do inquilino.

• Defina as propriedades na tabela a seguir usando o método InferenceScope.Start.

  Dados	Description
  details.operationName	Identificador de telemetria para a operação de inferência.
  details.model	Nome do modelo usado para satisfazer o pedido de inferência.
  details.providerName	O provedor responsável pela chamada de inferência.
  agentDetails.agentId	O identificador exclusivo do agente.
  agentDetails.agentName	Nome de exibição do agente.
  agentDetails.agentAUID	Azure User ID (AUID) para o agente.
  agentDetails.agentUPN	Nome Principal do Usuário (UPN) para o agente.
  agentDetails.agentBlueprintId	Projeto/ID de aplicação para o agente.
  agentDetails.tenantId	ID de inquilino do corretor.
  tenantDetails.tenantId	O identificador do inquilino.
  parentId	Para gerenciamento explícito do escopo dos pais. Não é obrigatório na maioria dos casos.