Use Agent365ExporterOptions for exporter and create AgenticTokenCache…

packages/agents-a365-observability/src/ObservabilityBuilder.ts

@@ -7,6 +7,7 @@ import { ConsoleSpanExporter, BatchSpanProcessor } from '@opentelemetry/sdk-trac
 import { SpanProcessor } from './tracing/processors/SpanProcessor';
 import { isAgent365ExporterEnabled } from './tracing/util';
 import { Agent365Exporter, TokenResolver } from './tracing/exporter/Agent365Exporter';
+import { Agent365ExporterOptions } from './tracing/exporter/Agent365ExporterOptions';
 import { resourceFromAttributes } from '@opentelemetry/resources';
 import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 import { trace } from '@opentelemetry/api';
@@ -67,20 +68,24 @@ export class ObservabilityBuilder {
     return this;
   }
 
-  private getTraceExporter() {
-    if (isAgent365ExporterEnabled()){
-      if (!this.options.tokenResolver) {
-        throw new Error('tokenResolver must be provided when Agent365 exporter is enabled');
-      }
-      return new Agent365Exporter(
-        this.options.tokenResolver,
-        this.options.clusterCategory || 'prod'
-      );
-    } else {
-      return new ConsoleSpanExporter();
+  private createBatchProcessor(): BatchSpanProcessor {
+    if (!isAgent365ExporterEnabled()) {
+      return new BatchSpanProcessor(new ConsoleSpanExporter());
     }
+    const opts = new Agent365ExporterOptions();
+    opts.clusterCategory = this.options.clusterCategory || 'prod';
+    if (this.options.tokenResolver) {
+      opts.tokenResolver = this.options.tokenResolver;
+    }
+    return new BatchSpanProcessor(new Agent365Exporter(opts), {
+      maxQueueSize: opts.maxQueueSize,
+      scheduledDelayMillis: opts.scheduledDelayMilliseconds,
+      exportTimeoutMillis: opts.exporterTimeoutMilliseconds,
+      maxExportBatchSize: opts.maxExportBatchSize
+    });
   }
 
+
   private createResource() {
     const serviceName = this.options.serviceVersion
       ? `${this.options.serviceName}-${this.options.serviceVersion}`
@@ -104,7 +109,7 @@ export class ObservabilityBuilder {
     const spanProcessor = new SpanProcessor();
 
     // 2. batch processor that actually ships spans out
-    const batchProcessor = new BatchSpanProcessor(this.getTraceExporter());
+    const batchProcessor = this.createBatchProcessor();
 
     const globalProvider: any = trace.getTracerProvider();
 

packages/agents-a365-observability/src/tracing/exporter/Agent365Exporter.ts

@@ -3,7 +3,9 @@ import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
 
 import { PowerPlatformApiDiscovery, ClusterCategory } from '@microsoft/agents-a365-runtime';
 import { partitionByIdentity, parseIdentityKey, hexTraceId, hexSpanId, kindName, statusName } from './utils';
-import logger, {formatError} from '../../utils/logging';
+import logger, { formatError } from '../../utils/logging';
+import { AgenticTokenCacheInstance } from '../../utils/AgenticTokenCache';
+import { Agent365ExporterOptions } from './Agent365ExporterOptions';
 
 const DEFAULT_HTTP_TIMEOUT_SECONDS = 30000; // 30 seconds in ms
 const DEFAULT_MAX_RETRIES = 3;
@@ -14,7 +16,7 @@ interface OTLPExportRequest {
 
 interface ResourceSpan {
   resource: {
-    attributes: Record<string, any> | null;
+    attributes: Record<string, unknown> | null;
   };
   scopeSpans: ScopeSpan[];
 }
@@ -35,7 +37,7 @@ interface OTLPSpan {
   kind: string;
   startTimeUnixNano: number;
   endTimeUnixNano: number;
-  attributes: Record<string, any> | null;
+  attributes: Record<string, unknown> | null;
   events?: OTLPEvent[] | null;
   links?: OTLPLink[] | null;
   status: OTLPStatus;
@@ -44,13 +46,13 @@ interface OTLPSpan {
 interface OTLPEvent {
   timeUnixNano: number;
   name: string;
-  attributes?: Record<string, any> | null;
+  attributes?: Record<string, unknown> | null;
 }
 
 interface OTLPLink {
   traceId: string;
   spanId: string;
-  attributes?: Record<string, any> | null;
+  attributes?: Record<string, unknown> | null;
 }
 
 interface OTLPStatus {
@@ -71,20 +73,32 @@ export type TokenResolver = (agentId: string, tenantId: string) => string | null
  * - Adds Bearer token via token_resolver(agentId, tenantId)
  */
 export class Agent365Exporter implements SpanExporter {
-  private readonly tokenResolver: TokenResolver;
-  private readonly clusterCategory: ClusterCategory;
   private closed = false;
+  private readonly options: Agent365ExporterOptions;
 
-  constructor(
-    tokenResolver: TokenResolver,
-    clusterCategory: ClusterCategory = 'prod'
-  ) {
-    if (!tokenResolver) {
-      logger.error('[Agent365Exporter] token_resolver is not provided');
-      throw new Error('token_resolver must be provided.');
+  /**
+   * Initialize exporter with a fully constructed options instance.
+   * If tokenResolver is missing, installs cache-backed resolver.
+   */
+  constructor(options: Agent365ExporterOptions) {
+
+    if (!options.tokenResolver) {
+      options.tokenResolver = (agentId: string, tenantId: string): string | null => {
+        const key = AgenticTokenCacheInstance.createCacheKey(agentId, tenantId);
+        const cached = AgenticTokenCacheInstance.get(key);
+        if (!cached) {
+          logger.warn('Token cache miss', { agentId, tenantId });
+        } else {
+          logger.info('Token cache hit', { agentId, tenantId });
+        }
+        return cached;
+      };
+      logger.info('Agent365Exporter initialized with cache-backed tokenResolver', `clusterCategory=${options.clusterCategory}`);
+    } else {
+      logger.info('Agent365Exporter initialized with custom tokenResolver', `clusterCategory=${options.clusterCategory}`);
     }
-    this.tokenResolver = tokenResolver;
-    this.clusterCategory = clusterCategory;
+
+    this.options = options;
   }
 
   /**
@@ -140,7 +154,7 @@ export class Agent365Exporter implements SpanExporter {
     const body = JSON.stringify(payload);
 
     // Resolve endpoint + token
-    const discovery = new PowerPlatformApiDiscovery(this.clusterCategory);
+    const discovery = new PowerPlatformApiDiscovery(this.options.clusterCategory as ClusterCategory);
     const endpoint = discovery.getTenantIslandClusterEndpoint(tenantId);
     const url = `https://${endpoint}/maven/agent365/agents/${agentId}/traces?api-version=1`;
     logger.info(`[Agent365Exporter] Resolved endpoint: ${endpoint}`);
@@ -149,7 +163,7 @@ export class Agent365Exporter implements SpanExporter {
       'content-type': 'application/json'
     };
 
-    const tokenResult = this.tokenResolver(agentId, tenantId);
+    const tokenResult = this.options.tokenResolver!(agentId, tenantId);
     const token = tokenResult instanceof Promise ? await tokenResult : tokenResult;
     if (token) {
       headers['authorization'] = `Bearer ${token}`;

packages/agents-a365-observability/src/tracing/exporter/Agent365ExporterOptions.ts

@@ -0,0 +1,49 @@
+// ------------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// ------------------------------------------------------------------------------
+
+import { ClusterCategory } from '@microsoft/agents-a365-runtime';
+import { TokenResolver } from './Agent365Exporter';
+
+/**
+ * Configuration for Agent365Exporter.
+ * Only ClusterCategory and TokenResolver are required for core operation.
+ */
+export class Agent365ExporterOptions {
+  /**
+   * Environment / cluster category
+   */
+  public clusterCategory: ClusterCategory | string = 'preprod';
+
+  /**
+  * Resolver used to resolve the auth token. Optional - falls back to AgenticTokenCache when not provided.
+   */
+  public tokenResolver?: TokenResolver;
+
+  /**
+   * When true, uses the service-to-service (S2S) endpoint path: /maven/agent365/service/agents/{agentId}/traces
+   * When false (default), uses the standard endpoint path: /maven/agent365/agents/{agentId}/traces
+   */
+  public useS2SEndpoint: boolean = false;
+
+  /**
+   * Maximum queue size for the batch processor.
+   */
+  public maxQueueSize: number = 2048;
+
+  /**
+   * Delay in milliseconds between export batches.
+   */
+  public scheduledDelayMilliseconds: number = 5000;
+
+  /**
+   * Timeout in milliseconds for the export operation.
+   */
+  public exporterTimeoutMilliseconds: number = 30000;
+
+  /**
+   * Maximum batch size for export operations.
+   */
+  public maxExportBatchSize: number = 512;
+}

packages/agents-a365-observability/src/utils/AgenticTokenCache.ts

@@ -0,0 +1,68 @@
+// ------------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ------------------------------------------------------------------------------
+
+/**
+ * Options for configuring the AgenticTokenCache.
+ */
+export interface AgenticTokenCacheOptions {
+  /** Default time-to-live in milliseconds applied when set() is called without an explicit ttl. */
+  defaultTtlMs?: number;
+}
+
+interface CacheEntry {
+  token: string;
+  /** Expiration timestamp in epoch milliseconds. */
+  expiresAt: number;
+  /** Creation timestamp. */
+  createdAt: number;
+}
+
+/**
+ * Lightweight in-memory TTL cache for agent tokens.
+ * Minimal parity with C# version: set/get with expiration and cache key helper.
+ */
+export class AgenticTokenCache {
+  private readonly options: Required<AgenticTokenCacheOptions>;
+  private readonly store: Map<string, CacheEntry> = new Map();
+
+  constructor(options?: AgenticTokenCacheOptions) {
+    this.options = {
+      defaultTtlMs: options?.defaultTtlMs ?? 50 * 60 * 1000
+    };
+  }
+
+  /** Create a cache key from agent/tenant identifiers. */
+  createCacheKey(agentId: string, tenantId?: string): string {
+    return tenantId ? `${agentId}:${tenantId}` : agentId;
+  }
+
+  /** Set a token value with optional TTL override. */
+  set(key: string, token: string, ttlMs?: number): void {
+    const now = Date.now();
+    const ttl = ttlMs ?? this.options.defaultTtlMs;
+    const expiresAt = now + Math.max(0, ttl);
+
+    this.store.set(key, { token, expiresAt, createdAt: now });
+  }
+
+  /** Retrieve a token if present and not expired; otherwise returns null. */
+  get(key: string): string | null {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.token;
+  }
+
+  /** Clear all cache entries (primarily for test isolation). */
+  clear(): void {
+    this.store.clear();
+  }
+}
+
+export const AgenticTokenCacheInstance = new AgenticTokenCache();

tests-agent/basic-agent-sdk-sample/src/index.ts

@@ -18,6 +18,7 @@ a365Observability.start();
 
 // Mock authentication middleware for development
 // This is only required when running from agents playground
+try {
 app.use((req: Request, res: Response, next: NextFunction) => {
   // Create a mock identity when JWT is disabled
   req.user = {
@@ -27,12 +28,36 @@ app.use((req: Request, res: Response, next: NextFunction) => {
   }
   next()
 })
+} catch (err) {
+  console.warn('Skipping mock authentication middleware:', err);
+}
 
 app.post('/api/messages', async (req: Request, res: Response) => {
-  await adapter.process(req, res, async (context) => {
-    const app = agentApplication;
-    await app.run(context);
-  });
+  try {
+    await adapter.process(req, res, async (context) => {
+      const app = agentApplication;
+      await app.run(context);
+    });
+  } catch (err) {
+    // Enhanced diagnostic logging for token acquisition / adapter failures
+    const anyErr = err as any;
+    const status = anyErr?.status || anyErr?.response?.status;
+    const data = anyErr?.response?.data;
+    const message = anyErr?.message || 'Unknown error';
+    // Axios style nested config
+    const aadError = data?.error || data?.error_description || data;
+    console.error('[diagnostic] adapter.process failed', {
+      message,
+      status,
+      aadError,
+      url: anyErr?.config?.url,
+      scope: anyErr?.config?.data,
+    });
+    // Surface minimal info to caller while keeping internals in log
+    if (!res.headersSent) {
+      res.status(500).json({ error: 'internal_error', detail: status ? `upstream status ${status}` : message });
+    }
+  }
 });
 
 const port = process.env.PORT || 3978;