Observabilidad del 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

Las variables de entorno necesarias para la observabilidad son:

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

Excluya la resolución de tokens para iniciar sesión en la consola.

Las variables de entorno necesarias para la observabilidad son:

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

Establezca EnableAgent365Exporter en trueappsettings.json.

En Program.cs, agregue Agent365ExporterOptions a la colección del servicio. Este cambio configura el delegado que usa el exportador de seguimiento para recuperar el token.

Agregue dependencias relacionadas con la observabilidad mediante 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
  };

Agregue el solucionador de tokens de agente a la colección de servicios.

using Microsoft.Agents.A365.Observability;

builder.Services.AddAgenticTracingExporter();

En la aplicación del agente, registre el 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 el paquete

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

Configuración de la observabilidad

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

El kernel semántico no se admite con JavaScript.

Agregue dependencias a la colección del servicio.

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

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

Establezca AgentId y TenantId usando BaggageBuilder. Asegúrese de que el id. usado al crear un ChatCompletionAgent coincide con el id. de agente pasado 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>,
          ...
      };
    }
}

Instale el paquete .

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

Configure la observabilidad.

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 el paquete

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

Configuración de la observabilidad

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

Agregue dependencias a la colección del servicio.

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

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

Establezca AgentId y TenantId usando BaggageBuilder. En el caso de las llamadas a herramientas, inicie un seguimiento mediante Trace() en una instancia de 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>);
    }
}

Instalar el paquete

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

Configuración de la observabilidad

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 no se admite con JavaScript.

Agregue dependencias a la colección del servicio.

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

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

Establezca AgentId y 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; }
}

Establezca la variable de entorno ENABLE_A365_OBSERVABILITY_EXPORTER en false. Esta exportación abarca (seguimientos) a la consola.

Establezca la variable de entorno ENABLE_A365_OBSERVABILITY_EXPORTER en false. Esta exportación abarca (seguimientos) a la consola.

Establezca EnableAgent365Exporter en falseappsettings.json. Esta exportación abarca (seguimientos) a la consola.

• Las propiedades establecidas usando la clase BaggageBuilder pueden ser establecidas o anuladas por las propiedades de los respectivos ámbitos.

• Establezca las propiedades en la siguiente tabla usando el método InvokeAgentScope.start.

  Data	Descripción
  invoke_agent_details.details.agent_id	Identificador único para el agente de IA
  invoke_agent_details.details.agent_name	El nombre legible del agente de IA
  invoke_agent_details.details.agent_auid	Identificador de usuario del agente (AUID)
  invoke_agent_details.details.agent_upn	El nombre principal de usuario del agente (UPN)
  invoke_agent_details.details.agent_blueprint_id	El plano técnico del agente o el identificador de aplicación
  invoke_agent_details.details.tenant_id	Identificador de inquilino del agente
  invoke_agent_details.details.conversation_id	Identificador de la conversación o sesión
  invoke_agent_details.endpoint	Punto de conexión de la invocación del agente
  tenant_details.tenant_id	Identificador único del inquilino
  request.content	El contenido de la carga útil enviado al agente para su invocación
  request.execution_type	Tipo de invocación que indica el origen de la solicitud (por ejemplo, HumanToAgent o AgentToAgent)
  caller_details.caller_id	Identificador único del autor de la llamada
  caller_details.caller_upn	Nombre principal de usuario (UPN) del autor de la llamada
  caller_details.caller_user_id	Identificador de usuario del autor de la llamada
  caller_details.tenant_id	Identificador de inquilino del autor de la llamada

• Establezca las propiedades en la siguiente tabla usando el método ExecuteToolScope.start.

  Data	Descripción
  details.tool_name	Nombre de la herramienta que se está ejecutando
  details.arguments	Argumentos y parámetros de la herramienta
  details.tool_call_id	Identificador único de la llamada a la herramienta
  details.tool_type	Tipo de la herramienta que se está ejecutando
  details.endpoint	Si se realiza una llamada a una herramienta externa
  agent_details.agent_id	Identificador único para el agente de IA
  agent_details.agent_name	El nombre legible del agente de IA
  agent_details.agent_auid	El ID de usuario del agente
  agent_details.agent_upn	El nombre principal de usuario del agente (UPN)
  agent_details.agent_blueprint_id	El plano técnico del agente o el identificador de aplicación
  agent_details.tenant_id	Identificación de inquilino del agente.
  agent_details.conversation_id	El ID de conversación para la invocación del agente.
  tenant_details.tenant_id	Identificación de inquilino del agente.

• Establezca las propiedades en la siguiente tabla usando el método InferenceScope.start.

  Data	Descripción
  details.operationName	Nombre o tipo de la operación para la inferencia
  details.model	El nombre o identificador del modelo
  details.providerName	El nombre del proveedor
  agent_details.agent_id	Identificador único para el agente de IA
  agent_details.agent_name	El nombre legible del agente de IA
  agent_details.agent_auid	Identificador de usuario del agente (AUID)
  agent_details.agent_upn	El nombre principal de usuario del agente (UPN)
  agent_details.agent_blueprint_id	El plano técnico del agente o el identificador de aplicación
  agent_details.tenant_id	Identificador único del inquilino
  agent_details.conversation_id	Identificador de la conversación o sesión
  tenant_details.tenant_id	Identificador único del inquilino
  request.content	El contenido de la carga útil enviado al agente para inferencia
  request.execution_type	Tipo de invocación que indica el origen de la solicitud (por ejemplo, HumanToAgent o AgentToAgent)
  request.source_metadata	Representa la información del canal

• Las propiedades establecidas usando la clase BaggageBuilder pueden ser establecidas o anuladas por las propiedades de los respectivos ámbitos.

• Establezca las propiedades en la siguiente tabla usando el método InvokeAgentScope.start.

  Data	Descripción
  invokeAgentDetails.agentAUID	Identificador de usuario del agente (AUID)
  invokeAgentDetails.agentBlueprintId	El plano técnico del agente o el identificador de aplicación
  invokeAgentDetails.agentId	Identificador único para el agente de IA
  invokeAgentDetails.agentName	El nombre legible del agente de IA
  invokeAgentDetails.agentUPN	El nombre principal de usuario del agente (UPN)
  invokeAgentDetails.conversationId	Identificador de la conversación o sesión
  invokeAgentDetails.endpoint.host	La dirección del host del punto final para la invocación del agente
  invokeAgentDetails.endpoint.port	El número de puerto del extremo para la invocación del agente
  invokeAgentDetails.endpoint.protocol	El punto final del protocolo para la invocación del agente
  invokeAgentDetails.request.content	El contenido de la carga útil de solicitud para la invocación del agente
  invokeAgentDetails.request.executionType	El tipo de invocación de la carga útil de solicitud para la invocación del agente
  invokeAgentDetails.request.sourceMetadata.name	Canaliza información como (msteams, email, y así sucesivamente)
  invokeAgentDetails.tenantId	Identificador de inquilino del agente
  tenantDetails.tenantId	Identificador único del inquilino
  callerDetails.callerId	El identificador único para el llamante (aadObjectId)
  callerDetails.callerName	El nombre para mostrar de la persona que llama
  callerDetails.callerUpn	Nombre principal de usuario (UPN) del autor de la llamada
  callerDetails.tenantId	Identificador de inquilino del autor de la llamada

• Establezca las propiedades en la siguiente tabla usando el método ExecuteToolScope.start.

  Data	Descripción
  details.arguments	Argumentos y parámetros de la herramienta
  details.endpoint.host	La dirección del host del endpoint para la ejecución de la herramienta. Obligatorio si se realiza una llamada externa
  details.endpoint.port	El número de puerto del endpoint para la ejecución de la herramienta. Obligatorio si se realiza una llamada externa
  details.endpoint.protocol	El protocolo del endpoint para la ejecución de la herramienta. Obligatorio si se realiza una llamada externa
  details.toolCallId	Identificador único de la llamada a la herramienta
  details.toolName	Nombre de la herramienta que se está ejecutando
  details.toolType	Tipo de la herramienta que se está ejecutando
  agentDetails.agentId	Identificador único para el agente de IA
  agentDetails.agentName	El nombre legible del agente de IA
  agentDetails.conversationId	Identificador de la conversación o sesión
  tenantDetails.tenantId	Identificador único del inquilino

• Establezca las propiedades en la siguiente tabla usando el método InferenceScope.start.

  Data	Descripción
  details.model	El nombre o identificador del modelo
  details.operationName	Nombre o tipo de la operación para la inferencia
  details.providerName	El nombre del proveedor
  agentDetails.agentId	Identificador único para el agente de IA
  agentDetails.agentName	El nombre legible del agente de IA
  agentDetails.conversationId	Identificador de la conversación o sesión
  tenantDetails.tenantId	Identificador único del inquilino

• Las propiedades establecidas usando la clase BaggageBuilder pueden ser establecidas o anuladas por las propiedades de los respectivos ámbitos.

• Establezca las propiedades en la siguiente tabla usando el método InvokeAgentScope.Start.

  Data	Descripción
  invokeAgentDetails.details.agentId	Identificador único del agente.
  invokeAgentDetails.details.agentName	Muestra el nombre del agente.
  invokeAgentDetails.details.agentAUID	Azure User ID (AUID) para el agente.
  invokeAgentDetails.details.agentUPN	Nombre principal de usuario (UPN) para el agente.
  invokeAgentDetails.details.agentBlueprintId	Plano o ID de solicitud para el agente.
  invokeAgentDetails.details.tenantId	Identificación de inquilino del agente.
  invokeAgentDetails.endpoint	URI del endpoint del agente a invocar.
  tenantDetails.tenantId	El identificador del inquilino.
  request.content	El contenido de la carga útil se suministraba al agente.
  request.executionType	Tipo de ejecución que describe la solicitud.
  request.sourceMetadata.name	Nombre legible para humanos de la fuente. Nombre del canal.
  conversationId	El ID de conversación para la invocación del agente.

• Establezca las propiedades en la siguiente tabla usando el método ExecuteToolScope.Start.

  Data	Descripción
  details.toolName	Nombre de la herramienta que se está invocando.
  details.arguments	Los argumentos serializados pasaban a la herramienta.
  details.toolCallId	Identificador para la invocación de herramientas.
  details.toolType	Clasificación de tipos para la herramienta.
  details.endpoint	Endpoint necesario para la ejecución remota de herramientas.
  agentDetails.agentId	Identificador único del agente.
  agentDetails.agentName	Muestra el nombre del agente.
  agentDetails.agentAUID	Azure User ID (AUID) para el agente.
  agentDetails.agentUPN	Nombre principal de usuario (UPN) para el agente.
  agentDetails.agentBlueprintId	Plano o ID de solicitud para el agente.
  agentDetails.tenantId	Identificación de inquilino del agente.
  tenantDetails.tenantId	El identificador del inquilino.

• Establezca las propiedades en la siguiente tabla usando el método InferenceScope.Start.

  Data	Descripción
  details.operationName	Identificador de telemetría para la operación de inferencia.
  details.model	Nombre del modelo utilizado para satisfacer la solicitud de inferencia.
  details.providerName	Proveedor responsable de la llamada de inferencia.
  agentDetails.agentId	Identificador único del agente.
  agentDetails.agentName	Muestra el nombre del agente.
  agentDetails.agentAUID	Azure User ID (AUID) para el agente.
  agentDetails.agentUPN	Nombre principal de usuario (UPN) para el agente.
  agentDetails.agentBlueprintId	Plano o ID de solicitud para el agente.
  agentDetails.tenantId	Identificación de inquilino del agente.
  tenantDetails.tenantId	El identificador del inquilino.
  parentId	Para la gestión explícita del ámbito parental. No es obligatorio en la mayoría de los casos.