@cuylabs/agent-microsoft-opentelemetry 4.8.0

package/dist/chunk-S7XVXBY3.js

@@ -0,0 +1,966 @@
+// src/errors.ts
+var MicrosoftOpenTelemetryModuleLoadError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MicrosoftOpenTelemetryModuleLoadError";
+  }
+};
+var MicrosoftOpenTelemetryResourceModuleLoadError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MicrosoftOpenTelemetryResourceModuleLoadError";
+  }
+};
+
+// src/internal/values.ts
+function isNonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    if (isNonEmpty(value)) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function setPair(pairs, key, value) {
+  if (value === null || value === void 0) {
+    return;
+  }
+  const normalized = String(value).trim();
+  if (normalized) {
+    pairs[key] = normalized;
+  }
+}
+function parseOptionalNumber(value) {
+  if (!isNonEmpty(value)) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseOptionalBoolean(value) {
+  if (!isNonEmpty(value)) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return void 0;
+}
+function parseList(value) {
+  if (!isNonEmpty(value)) {
+    return [];
+  }
+  return value.split(/[,\s]+/).map((item) => item.trim()).filter(Boolean);
+}
+function readPath(value, path) {
+  let current = value;
+  for (const key of path) {
+    if (!current || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return typeof current === "string" && current.trim() ? current.trim() : void 0;
+}
+function callOptionalStringMethod(value) {
+  if (typeof value !== "function") {
+    return void 0;
+  }
+  try {
+    const result = value();
+    return typeof result === "string" && result.trim() ? result.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function callOptionalBooleanMethod(value) {
+  if (typeof value !== "function") {
+    return false;
+  }
+  try {
+    return value() === true;
+  } catch {
+    return false;
+  }
+}
+function parseServiceEndpoint(serviceUrl) {
+  if (!isNonEmpty(serviceUrl)) {
+    return void 0;
+  }
+  try {
+    const url = new URL(serviceUrl);
+    return {
+      serverAddress: url.hostname,
+      serverPort: url.port ? Number(url.port) : url.protocol === "http:" ? 80 : 443
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/auth/oauth-token-endpoint.ts
+var CLIENT_ASSERTION_TYPE = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
+var DEFAULT_TOKEN_LIFETIME_MS = 55 * 60 * 1e3;
+async function requestClientSecretToken(client, request, extra) {
+  const body = new URLSearchParams({
+    grant_type: "client_credentials",
+    client_id: request.clientId,
+    client_secret: request.clientSecret,
+    scope: request.scope
+  });
+  if (extra?.fmiPath) {
+    body.set("fmi_path", extra.fmiPath);
+  }
+  return await requestToken(client, body);
+}
+async function requestClientAssertionToken(client, request, extra) {
+  const body = new URLSearchParams({
+    grant_type: "client_credentials",
+    client_id: request.clientId,
+    client_assertion: request.clientAssertion,
+    client_assertion_type: CLIENT_ASSERTION_TYPE,
+    scope: request.scope
+  });
+  if (extra?.fmiPath) {
+    body.set("fmi_path", extra.fmiPath);
+  }
+  return await requestToken(client, body);
+}
+async function requestToken(client, body) {
+  const response = await client.fetch(
+    `https://login.microsoftonline.com/${encodeURIComponent(
+      client.tenantId
+    )}/oauth2/v2.0/token`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    }
+  );
+  const payload = parseTokenEndpointResponse(await response.text());
+  if (!response.ok || !payload.access_token) {
+    throw new Error(
+      payload.error_description || payload.error || `token endpoint returned HTTP ${response.status}`
+    );
+  }
+  const expiresInMs = typeof payload.expires_in === "number" && payload.expires_in > 0 ? payload.expires_in * 1e3 : DEFAULT_TOKEN_LIFETIME_MS;
+  return {
+    accessToken: payload.access_token,
+    expiresAtMs: Date.now() + expiresInMs
+  };
+}
+function parseTokenEndpointResponse(body) {
+  if (!body) {
+    return {};
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    return { error_description: body };
+  }
+}
+
+// src/auth/s2s-token-resolver.ts
+var MICROSOFT_A365_FMI_SCOPE = "api://AzureADTokenExchange/.default";
+var MICROSOFT_A365_OBSERVABILITY_SCOPE = "api://9b975845-388f-4429-889e-eab1ef63949c/.default";
+var DEFAULT_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+function createMicrosoftA365S2STokenResolver(options) {
+  const normalized = normalizeOptions(options);
+  const cache = /* @__PURE__ */ new Map();
+  return async (agentId, tenantId, authScopes) => {
+    const request = {
+      ...normalized,
+      agentId: firstNonEmpty(agentId, normalized.agentId) ?? "",
+      tenantId: firstNonEmpty(tenantId, normalized.tenantId) ?? "",
+      observabilityScope: firstNonEmpty(authScopes?.[0], normalized.observabilityScope) ?? MICROSOFT_A365_OBSERVABILITY_SCOPE
+    };
+    const cacheKey = `${request.tenantId}:${request.agentId}:${request.observabilityScope}`;
+    const cached = cache.get(cacheKey);
+    if (cached && cached.expiresAtMs - request.refreshSkewMs > Date.now()) {
+      return cached.accessToken;
+    }
+    try {
+      const token = await acquireObservabilityToken(request);
+      cache.set(cacheKey, token);
+      return token.accessToken;
+    } catch (error) {
+      request.logger?.warn("Failed to acquire Microsoft A365 S2S token", {
+        error: error instanceof Error ? error.message : String(error),
+        useManagedIdentity: request.useManagedIdentity
+      });
+      return null;
+    }
+  };
+}
+function normalizeOptions(options) {
+  return {
+    tenantId: requireNonEmpty("tenantId", options.tenantId),
+    agentId: requireNonEmpty("agentId", options.agentId),
+    blueprintClientId: requireNonEmpty(
+      "blueprintClientId",
+      options.blueprintClientId
+    ),
+    ...options.blueprintClientSecret ? { blueprintClientSecret: options.blueprintClientSecret } : {},
+    useManagedIdentity: options.useManagedIdentity ?? false,
+    ...options.managedIdentityAssertionProvider ? {
+      managedIdentityAssertionProvider: options.managedIdentityAssertionProvider
+    } : {},
+    allowManagedIdentityClientSecretFallback: options.allowManagedIdentityClientSecretFallback ?? true,
+    observabilityScope: options.observabilityScope ?? MICROSOFT_A365_OBSERVABILITY_SCOPE,
+    fmiScope: options.fmiScope ?? MICROSOFT_A365_FMI_SCOPE,
+    refreshSkewMs: options.refreshSkewMs ?? DEFAULT_REFRESH_SKEW_MS,
+    ...options.logger ? { logger: options.logger } : {},
+    fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+  };
+}
+async function acquireObservabilityToken(options) {
+  const fmiToken = await acquireFmiToken(options);
+  return await requestClientAssertionToken(options, {
+    clientId: options.agentId,
+    clientAssertion: fmiToken.accessToken,
+    scope: options.observabilityScope
+  });
+}
+async function acquireFmiToken(options) {
+  if (options.useManagedIdentity) {
+    try {
+      const assertion = await options.managedIdentityAssertionProvider?.();
+      if (!assertion) {
+        throw new Error(
+          "managed identity assertion provider returned no token"
+        );
+      }
+      return await requestClientAssertionToken(
+        options,
+        {
+          clientId: options.blueprintClientId,
+          clientAssertion: assertion,
+          scope: options.fmiScope
+        },
+        { fmiPath: options.agentId }
+      );
+    } catch (error) {
+      if (!options.allowManagedIdentityClientSecretFallback || !options.blueprintClientSecret) {
+        throw error;
+      }
+      options.logger?.warn(
+        "Managed identity FMI token exchange failed; falling back to blueprint client secret",
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+    }
+  }
+  return await requestClientSecretToken(
+    options,
+    {
+      clientId: options.blueprintClientId,
+      clientSecret: requireNonEmpty(
+        "blueprintClientSecret",
+        options.blueprintClientSecret
+      ),
+      scope: options.fmiScope
+    },
+    { fmiPath: options.agentId }
+  );
+}
+function requireNonEmpty(name, value) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`${name} is required`);
+  }
+  return normalized;
+}
+
+// src/auth/env.ts
+function resolveMicrosoftOpenTelemetryEnvironment(env = process.env) {
+  const reader = createEnvReader(env);
+  const enableObservabilityExporter = parseOptionalBoolean(
+    reader(
+      "ENABLE_A365_OBSERVABILITY_EXPORTER",
+      "A365_OBSERVABILITY_EXPORTER_ENABLED",
+      "agent365Observability__exporterEnabled"
+    )
+  );
+  return {
+    resource: {
+      serviceName: reader(
+        "MICROSOFT_OTEL_SERVICE_NAME",
+        "OTEL_SERVICE_NAME",
+        "A365_OBSERVABILITY_SERVICE_NAME"
+      ),
+      serviceVersion: reader(
+        "MICROSOFT_OTEL_SERVICE_VERSION",
+        "OTEL_SERVICE_VERSION",
+        "A365_OBSERVABILITY_SERVICE_VERSION"
+      ),
+      serviceNamespace: reader(
+        "MICROSOFT_OTEL_SERVICE_NAMESPACE",
+        "OTEL_SERVICE_NAMESPACE"
+      ),
+      serviceInstanceId: reader(
+        "MICROSOFT_OTEL_SERVICE_INSTANCE_ID",
+        "OTEL_SERVICE_INSTANCE_ID"
+      )
+    },
+    a365: {
+      enabled: parseOptionalBoolean(
+        reader("MICROSOFT_OTEL_A365_ENABLED", "A365_OBSERVABILITY_ENABLED")
+      ),
+      enableObservabilityExporter,
+      exporterEnabled: enableObservabilityExporter,
+      clusterCategory: reader(
+        "A365_OBSERVABILITY_CLUSTER_CATEGORY",
+        "CLUSTER_CATEGORY"
+      ),
+      domainOverride: reader(
+        "A365_OBSERVABILITY_DOMAIN_OVERRIDE",
+        "agent365Observability__domainOverride"
+      ),
+      authScopes: firstDefinedList(
+        parseList(
+          reader(
+            "A365_OBSERVABILITY_AUTHENTICATION_SCOPES",
+            "A365_OBSERVABILITY_SCOPES_OVERRIDE",
+            "agent365Observability__authenticationScopes"
+          )
+        )
+      ),
+      observabilityScopeOverride: reader(
+        "A365_OBSERVABILITY_SCOPE_OVERRIDE",
+        "A365_OBSERVABILITY_SCOPE",
+        "agent365Observability__observabilityScope"
+      ),
+      logLevel: reader(
+        "A365_OBSERVABILITY_LOG_LEVEL",
+        "agent365Observability__logLevel"
+      ),
+      useS2SEndpoint: parseOptionalBoolean(
+        reader(
+          "A365_OBSERVABILITY_USE_S2S_ENDPOINT",
+          "agent365Observability__useS2SEndpoint"
+        )
+      ),
+      maxQueueSize: parseOptionalNumber(
+        reader("A365_OBSERVABILITY_MAX_QUEUE_SIZE")
+      ),
+      scheduledDelayMilliseconds: parseOptionalNumber(
+        reader("A365_OBSERVABILITY_SCHEDULED_DELAY_MS")
+      ),
+      exporterTimeoutMilliseconds: parseOptionalNumber(
+        reader("A365_OBSERVABILITY_EXPORTER_TIMEOUT_MS")
+      ),
+      httpRequestTimeoutMilliseconds: parseOptionalNumber(
+        reader("A365_OBSERVABILITY_HTTP_REQUEST_TIMEOUT_MS")
+      ),
+      maxExportBatchSize: parseOptionalNumber(
+        reader("A365_OBSERVABILITY_MAX_EXPORT_BATCH_SIZE")
+      ),
+      maxPayloadBytes: parseOptionalNumber(
+        reader("A365_OBSERVABILITY_MAX_PAYLOAD_BYTES")
+      )
+    },
+    azureMonitorEnabled: parseOptionalBoolean(
+      reader("MICROSOFT_OTEL_AZURE_MONITOR_ENABLED")
+    ),
+    instrumentationProfile: parseInstrumentationProfile(
+      reader("MICROSOFT_OTEL_INSTRUMENTATION_PROFILE")
+    ),
+    enableConsoleExporters: parseOptionalBoolean(
+      reader("MICROSOFT_OTEL_ENABLE_CONSOLE_EXPORTERS")
+    )
+  };
+}
+function createMicrosoftA365S2STokenResolverFromEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const reader = createEnvReader(env);
+  const tenantId = requireValue(
+    "tenantId",
+    firstNonEmpty(
+      options.tenantId,
+      reader("A365_OBSERVABILITY_TENANT_ID", "agent365Observability__tenantId")
+    )
+  );
+  const agentId = requireValue(
+    "agentId",
+    firstNonEmpty(
+      options.agentId,
+      reader("A365_OBSERVABILITY_AGENT_ID", "agent365Observability__agentId")
+    )
+  );
+  const blueprintClientId = requireValue(
+    "blueprintClientId",
+    firstNonEmpty(
+      options.blueprintClientId,
+      reader(
+        "A365_OBSERVABILITY_BLUEPRINT_CLIENT_ID",
+        "A365_OBSERVABILITY_CLIENT_ID",
+        "agent365Observability__clientId",
+        "agent365Observability__agentBlueprintId"
+      )
+    )
+  );
+  return createMicrosoftA365S2STokenResolver({
+    ...options,
+    tenantId,
+    agentId,
+    blueprintClientId,
+    blueprintClientSecret: firstNonEmpty(
+      options.blueprintClientSecret,
+      reader(
+        "A365_OBSERVABILITY_BLUEPRINT_CLIENT_SECRET",
+        "A365_OBSERVABILITY_CLIENT_SECRET",
+        "agent365Observability__clientSecret"
+      )
+    ),
+    useManagedIdentity: options.useManagedIdentity ?? parseOptionalBoolean(
+      reader(
+        "A365_OBSERVABILITY_USE_MANAGED_IDENTITY",
+        "agent365Observability__useManagedIdentity"
+      )
+    ) ?? Boolean(options.managedIdentityAssertionProvider),
+    observabilityScope: firstNonEmpty(
+      options.observabilityScope,
+      reader(
+        "A365_OBSERVABILITY_SCOPE",
+        "A365_OBSERVABILITY_SCOPES",
+        "agent365Observability__observabilityScope"
+      )
+    ),
+    fmiScope: firstNonEmpty(
+      options.fmiScope,
+      reader(
+        "A365_OBSERVABILITY_FMI_SCOPE",
+        "A365_FMI_SCOPE",
+        "agent365Observability__fmiScope"
+      )
+    )
+  });
+}
+function createEnvReader(env) {
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) {
+      normalized.set(key.toLowerCase(), value);
+    }
+  }
+  return (...names) => {
+    for (const name of names) {
+      const value = firstNonEmpty(
+        env[name],
+        normalized.get(name.toLowerCase())
+      );
+      if (value) {
+        return value;
+      }
+    }
+    return void 0;
+  };
+}
+function firstDefinedList(value) {
+  return value.length > 0 ? value : void 0;
+}
+function parseInstrumentationProfile(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "agent-core" || normalized === "microsoft-genai" || normalized === "agent365-genai" || normalized === "full-stack" || normalized === "manual" || normalized === "microsoft-default") {
+    return normalized;
+  }
+  return void 0;
+}
+function requireValue(name, value) {
+  if (!value) {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+}
+
+// src/a365/attributes.ts
+var MICROSOFT_A365_ATTRIBUTES = {
+  tenantId: "microsoft.tenant.id",
+  agentId: "gen_ai.agent.id",
+  agentName: "gen_ai.agent.name",
+  agentDescription: "gen_ai.agent.description",
+  agentVersion: "gen_ai.agent.version",
+  agentPlatformId: "microsoft.a365.agent.platform.id",
+  agentAuid: "microsoft.agent.user.id",
+  agentEmail: "microsoft.agent.user.email",
+  agentBlueprintId: "microsoft.a365.agent.blueprint.id",
+  sessionId: "microsoft.session.id",
+  sessionDescription: "microsoft.session.description",
+  conversationId: "gen_ai.conversation.id",
+  conversationItemLink: "microsoft.conversation.item.link",
+  channelName: "microsoft.channel.name",
+  channelLink: "microsoft.channel.link",
+  userId: "user.id",
+  userName: "user.name",
+  userEmail: "user.email",
+  callerClientIp: "client.address",
+  callerAgentId: "microsoft.a365.caller.agent.id",
+  callerAgentName: "microsoft.a365.caller.agent.name",
+  callerAgentAuid: "microsoft.a365.caller.agent.user.id",
+  callerAgentEmail: "microsoft.a365.caller.agent.user.email",
+  callerAgentBlueprintId: "microsoft.a365.caller.agent.blueprint.id",
+  callerAgentPlatformId: "microsoft.a365.caller.agent.platform.id",
+  callerAgentVersion: "microsoft.a365.caller.agent.version",
+  serviceName: "service.name",
+  serverAddress: "server.address",
+  serverPort: "server.port"
+};
+
+// src/a365/baggage.ts
+function buildMicrosoftA365BaggagePairs(context) {
+  const pairs = {};
+  for (const [key, value] of Object.entries(context.extraBaggage ?? {})) {
+    setPair(pairs, key, value);
+  }
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.tenantId, context.tenantId);
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.agentId, context.agentId);
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.agentName, context.agentName);
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.agentDescription,
+    context.agentDescription
+  );
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.agentVersion, context.agentVersion);
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.agentPlatformId,
+    context.agentPlatformId
+  );
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.agentAuid, context.agentAuid);
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.agentEmail, context.agentEmail);
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.agentBlueprintId,
+    context.agentBlueprintId
+  );
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.sessionId, context.sessionId);
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.sessionDescription,
+    context.sessionDescription
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.conversationId,
+    context.conversationId
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.conversationItemLink,
+    context.conversationItemLink
+  );
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.channelName, context.channelName);
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.channelLink, context.channelLink);
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.userId, context.userId);
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.userName, context.userName);
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.userEmail, context.userEmail);
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerClientIp,
+    context.callerClientIp
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerAgentId,
+    context.callerAgentId
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerAgentName,
+    context.callerAgentName
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerAgentAuid,
+    context.callerAgentAuid
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerAgentEmail,
+    context.callerAgentEmail
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerAgentBlueprintId,
+    context.callerAgentBlueprintId
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerAgentPlatformId,
+    context.callerAgentPlatformId
+  );
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.callerAgentVersion,
+    context.callerAgentVersion
+  );
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.serviceName, context.serviceName);
+  setPair(
+    pairs,
+    MICROSOFT_A365_ATTRIBUTES.serverAddress,
+    context.serverAddress
+  );
+  setPair(pairs, MICROSOFT_A365_ATTRIBUTES.serverPort, context.serverPort);
+  return pairs;
+}
+
+// src/runtime/module-loader.ts
+var MICROSOFT_OPENTELEMETRY_PACKAGE = "@microsoft/opentelemetry";
+var OTEL_RESOURCES_PACKAGE = "@opentelemetry/resources";
+async function loadMicrosoftOpenTelemetryModule(options = {}) {
+  try {
+    if (options.getDistroModule) {
+      return await options.getDistroModule();
+    }
+    return await import(MICROSOFT_OPENTELEMETRY_PACKAGE);
+  } catch (error) {
+    throw new MicrosoftOpenTelemetryModuleLoadError(
+      `Unable to load ${MICROSOFT_OPENTELEMETRY_PACKAGE}. Install @microsoft/opentelemetry before using @cuylabs/agent-microsoft-opentelemetry.`,
+      { cause: error }
+    );
+  }
+}
+async function loadOpenTelemetryResourceModule(options = {}) {
+  try {
+    if (options.getResourceModule) {
+      return await options.getResourceModule();
+    }
+    return await import(OTEL_RESOURCES_PACKAGE);
+  } catch (error) {
+    throw new MicrosoftOpenTelemetryResourceModuleLoadError(
+      `Unable to load ${OTEL_RESOURCES_PACKAGE}. It is installed with @microsoft/opentelemetry and is required when resource options are supplied.`,
+      { cause: error }
+    );
+  }
+}
+
+// src/tracing/tracing-config.ts
+function createMicrosoftOpenTelemetryTracingConfig(options = {}) {
+  const spanAttributes = {
+    ...options.spanAttributes ?? {}
+  };
+  if (isNonEmpty(options.tenantId)) {
+    spanAttributes[MICROSOFT_A365_ATTRIBUTES.tenantId] = options.tenantId.trim();
+  }
+  return {
+    ...isNonEmpty(options.agentId) ? { agentId: options.agentId.trim() } : {},
+    ...isNonEmpty(options.agentDescription) ? { agentDescription: options.agentDescription.trim() } : {},
+    ...isNonEmpty(options.agentVersion) ? { agentVersion: options.agentVersion.trim() } : {},
+    ...options.recordInputs !== void 0 ? { recordInputs: options.recordInputs } : {},
+    ...options.recordOutputs !== void 0 ? { recordOutputs: options.recordOutputs } : {},
+    emitToolSpans: options.emitToolSpans ?? false,
+    ...options.useGenAIOpenTelemetry !== void 0 ? { useGenAIOpenTelemetry: options.useGenAIOpenTelemetry } : {},
+    ...options.telemetryIntegrations ? { telemetryIntegrations: options.telemetryIntegrations } : {},
+    ...options.useGlobalTelemetryIntegrations !== void 0 ? {
+      useGlobalTelemetryIntegrations: options.useGlobalTelemetryIntegrations
+    } : {},
+    ...Object.keys(spanAttributes).length > 0 ? { spanAttributes } : {}
+  };
+}
+
+// src/runtime/instrumentation.ts
+var INFRA_INSTRUMENTATION_KEYS = [
+  "http",
+  "azureSdk",
+  "mongoDb",
+  "mySql",
+  "postgreSql",
+  "redis",
+  "redis4",
+  "bunyan",
+  "winston"
+];
+var MICROSOFT_FRAMEWORK_INSTRUMENTATION_KEYS = [
+  "openaiAgents",
+  "langchain"
+];
+function createMicrosoftOpenTelemetryInstrumentationOptions(options = {}) {
+  const profile = normalizeInstrumentationProfile(options.profile);
+  const instrumentation = {};
+  if (profile === "microsoft-default") {
+    return mergeInstrumentationOptions(void 0, options.overrides);
+  }
+  if (profile === "agent-core") {
+    setEnabled(instrumentation, INFRA_INSTRUMENTATION_KEYS, false);
+    setEnabled(
+      instrumentation,
+      MICROSOFT_FRAMEWORK_INSTRUMENTATION_KEYS,
+      false
+    );
+  } else if (profile === "microsoft-genai") {
+    setEnabled(instrumentation, INFRA_INSTRUMENTATION_KEYS, false);
+    setEnabled(instrumentation, MICROSOFT_FRAMEWORK_INSTRUMENTATION_KEYS, true);
+  } else if (profile === "full-stack") {
+    setEnabled(instrumentation, INFRA_INSTRUMENTATION_KEYS, true);
+    setEnabled(instrumentation, MICROSOFT_FRAMEWORK_INSTRUMENTATION_KEYS, true);
+  } else if (profile === "manual") {
+    setEnabled(
+      instrumentation,
+      [
+        ...INFRA_INSTRUMENTATION_KEYS,
+        ...MICROSOFT_FRAMEWORK_INSTRUMENTATION_KEYS
+      ],
+      false
+    );
+  }
+  return mergeInstrumentationOptions(instrumentation, options.overrides);
+}
+function normalizeInstrumentationProfile(profile) {
+  if (profile === "agent365-genai") {
+    return "microsoft-genai";
+  }
+  return profile ?? "agent-core";
+}
+function mergeInstrumentationOptions(base, overrides) {
+  if (!base) {
+    return { ...overrides ?? {} };
+  }
+  if (!overrides) {
+    return { ...base };
+  }
+  return {
+    ...base,
+    ...overrides,
+    azureSdk: mergeConfig(base.azureSdk, overrides.azureSdk),
+    http: mergeConfig(base.http, overrides.http),
+    mongoDb: mergeConfig(base.mongoDb, overrides.mongoDb),
+    mySql: mergeConfig(base.mySql, overrides.mySql),
+    postgreSql: mergeConfig(base.postgreSql, overrides.postgreSql),
+    redis: mergeConfig(base.redis, overrides.redis),
+    redis4: mergeConfig(base.redis4, overrides.redis4),
+    bunyan: mergeConfig(base.bunyan, overrides.bunyan),
+    winston: mergeConfig(base.winston, overrides.winston),
+    openaiAgents: mergeConfig(base.openaiAgents, overrides.openaiAgents),
+    langchain: mergeConfig(base.langchain, overrides.langchain)
+  };
+}
+function setEnabled(target, keys, enabled) {
+  for (const key of keys) {
+    target[key] = { enabled };
+  }
+}
+function mergeConfig(base, override) {
+  if (!base && !override) {
+    return void 0;
+  }
+  return {
+    ...base ?? {},
+    ...override ?? {}
+  };
+}
+
+// src/runtime/lifecycle.ts
+async function initMicrosoftOpenTelemetry(options = {}) {
+  const module = await loadMicrosoftOpenTelemetryModule(options.runtime);
+  const resource = await createResource(options.resource, options.runtime);
+  const distroOptions = await createDistroOptions(options, resource);
+  module.useMicrosoftOpenTelemetry(distroOptions);
+  return {
+    tracing: createMicrosoftOpenTelemetryTracingConfig(options.agent),
+    shutdown: () => module.shutdownMicrosoftOpenTelemetry()
+  };
+}
+async function initMicrosoftOpenTelemetryFromEnv(options = {}) {
+  const env = resolveMicrosoftOpenTelemetryEnvironment(options.env);
+  const explicitA365Enabled = options.a365?.enabled ?? env.a365.enabled;
+  const exporterEnabled = options.a365?.enableObservabilityExporter ?? options.a365?.exporterEnabled ?? env.a365.enableObservabilityExporter ?? env.a365.exporterEnabled ?? false;
+  const a365Enabled = explicitA365Enabled ?? exporterEnabled;
+  return await initMicrosoftOpenTelemetry({
+    ...options,
+    resource: {
+      ...env.resource,
+      ...options.resource
+    },
+    a365: a365Enabled || exporterEnabled || options.a365 ? {
+      ...env.a365,
+      ...options.a365,
+      enabled: a365Enabled,
+      enableObservabilityExporter: exporterEnabled,
+      tokenResolver: options.a365?.tokenResolver ?? (a365Enabled && exporterEnabled ? createMicrosoftA365S2STokenResolverFromEnv({
+        env: options.env
+      }) : void 0)
+    } : void 0,
+    azureMonitor: env.azureMonitorEnabled !== void 0 ? { enabled: env.azureMonitorEnabled } : void 0,
+    instrumentationProfile: options.instrumentationProfile ?? env.instrumentationProfile,
+    enableConsoleExporters: options.enableConsoleExporters ?? env.enableConsoleExporters
+  });
+}
+async function runWithMicrosoftA365Context(requestContext, fn, options = {}) {
+  const module = await loadMicrosoftOpenTelemetryModule(options);
+  const runWithBaggage = () => {
+    const scope = new module.BaggageBuilder().setPairs(buildMicrosoftA365BaggagePairs(requestContext)).build();
+    return scope.run(fn);
+  };
+  const result = requestContext.exportToken && module.runWithExportToken ? module.runWithExportToken(requestContext.exportToken, runWithBaggage) : runWithBaggage();
+  return await result;
+}
+async function updateMicrosoftA365ExportToken(token, options = {}) {
+  const module = await loadMicrosoftOpenTelemetryModule(options);
+  return module.updateExportToken?.(token) ?? false;
+}
+async function createDistroOptions(options, resource) {
+  const distroOptions = {
+    ...options.distroOptions ?? {}
+  };
+  if (resource) {
+    distroOptions.resource = resource;
+  }
+  if (options.samplingRatio !== void 0) {
+    distroOptions.samplingRatio = options.samplingRatio;
+  }
+  if (options.tracesPerSecond !== void 0) {
+    distroOptions.tracesPerSecond = options.tracesPerSecond;
+  }
+  if (options.instrumentationProfile !== "microsoft-default" || options.instrumentationOptions) {
+    distroOptions.instrumentationOptions = createMicrosoftOpenTelemetryInstrumentationOptions({
+      profile: options.instrumentationProfile,
+      overrides: options.instrumentationOptions
+    });
+  }
+  if (options.spanProcessors) {
+    distroOptions.spanProcessors = [...options.spanProcessors];
+  }
+  if (options.logRecordProcessors) {
+    distroOptions.logRecordProcessors = [...options.logRecordProcessors];
+  }
+  if (options.metricReaders) {
+    distroOptions.metricReaders = [...options.metricReaders];
+  }
+  if (options.views) {
+    distroOptions.views = [...options.views];
+  }
+  if (options.azureMonitor !== void 0) {
+    distroOptions.azureMonitor = options.azureMonitor === false ? { enabled: false } : options.azureMonitor;
+  }
+  if (options.enableConsoleExporters !== void 0) {
+    distroOptions.enableConsoleExporters = options.enableConsoleExporters;
+  }
+  if (options.a365) {
+    distroOptions.a365 = createA365DistroOptions(options.a365);
+  }
+  return distroOptions;
+}
+function createA365DistroOptions(options) {
+  const a365 = {
+    enabled: options.enabled ?? true
+  };
+  const enableObservabilityExporter = options.enableObservabilityExporter ?? options.exporterEnabled;
+  if (enableObservabilityExporter !== void 0) {
+    a365.enableObservabilityExporter = enableObservabilityExporter;
+  }
+  if (options.tokenResolver) {
+    a365.tokenResolver = createDistroTokenResolver(options.tokenResolver);
+  }
+  setIfDefined(a365, "clusterCategory", options.clusterCategory);
+  setIfDefined(a365, "domainOverride", options.domainOverride);
+  setIfDefined(a365, "authScopes", options.authScopes);
+  setIfDefined(
+    a365,
+    "observabilityScopeOverride",
+    options.observabilityScopeOverride
+  );
+  setIfDefined(a365, "logLevel", options.logLevel);
+  setIfDefined(a365, "useS2SEndpoint", options.useS2SEndpoint);
+  setIfDefined(a365, "maxQueueSize", options.maxQueueSize);
+  setIfDefined(
+    a365,
+    "scheduledDelayMilliseconds",
+    options.scheduledDelayMilliseconds
+  );
+  setIfDefined(
+    a365,
+    "exporterTimeoutMilliseconds",
+    options.exporterTimeoutMilliseconds
+  );
+  setIfDefined(
+    a365,
+    "httpRequestTimeoutMilliseconds",
+    options.httpRequestTimeoutMilliseconds
+  );
+  setIfDefined(a365, "maxExportBatchSize", options.maxExportBatchSize);
+  setIfDefined(a365, "maxPayloadBytes", options.maxPayloadBytes);
+  return a365;
+}
+function createDistroTokenResolver(resolver) {
+  return async (agentId, tenantId, authScopes) => {
+    return await resolver(agentId, tenantId, authScopes) ?? "";
+  };
+}
+async function createResource(options, runtime) {
+  const attributes = createResourceAttributes(options);
+  if (!attributes) {
+    return void 0;
+  }
+  const resourceModule = await loadOpenTelemetryResourceModule(runtime);
+  return resourceModule.resourceFromAttributes(attributes);
+}
+function createResourceAttributes(options) {
+  const attributes = {
+    ...options?.attributes ?? {}
+  };
+  setStringAttribute(attributes, "service.name", options?.serviceName);
+  setStringAttribute(attributes, "service.version", options?.serviceVersion);
+  setStringAttribute(
+    attributes,
+    "service.namespace",
+    options?.serviceNamespace
+  );
+  setStringAttribute(
+    attributes,
+    "service.instance.id",
+    options?.serviceInstanceId
+  );
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
+}
+function resolveMicrosoftOpenTelemetryBooleanEnv(value) {
+  return parseOptionalBoolean(value);
+}
+function resolveMicrosoftOpenTelemetryNumberEnv(value) {
+  return parseOptionalNumber(value);
+}
+function setStringAttribute(attributes, key, value) {
+  if (isNonEmpty(value)) {
+    attributes[key] = value.trim();
+  }
+}
+function setIfDefined(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+
+export {
+  MicrosoftOpenTelemetryModuleLoadError,
+  MicrosoftOpenTelemetryResourceModuleLoadError,
+  firstNonEmpty,
+  readPath,
+  callOptionalStringMethod,
+  callOptionalBooleanMethod,
+  parseServiceEndpoint,
+  MICROSOFT_A365_FMI_SCOPE,
+  MICROSOFT_A365_OBSERVABILITY_SCOPE,
+  createMicrosoftA365S2STokenResolver,
+  resolveMicrosoftOpenTelemetryEnvironment,
+  createMicrosoftA365S2STokenResolverFromEnv,
+  createEnvReader,
+  MICROSOFT_A365_ATTRIBUTES,
+  buildMicrosoftA365BaggagePairs,
+  loadMicrosoftOpenTelemetryModule,
+  loadOpenTelemetryResourceModule,
+  createMicrosoftOpenTelemetryTracingConfig,
+  createMicrosoftOpenTelemetryInstrumentationOptions,
+  normalizeInstrumentationProfile,
+  mergeInstrumentationOptions,
+  initMicrosoftOpenTelemetry,
+  initMicrosoftOpenTelemetryFromEnv,
+  runWithMicrosoftA365Context,
+  updateMicrosoftA365ExportToken,
+  resolveMicrosoftOpenTelemetryBooleanEnv,
+  resolveMicrosoftOpenTelemetryNumberEnv
+};