@iqai/adk 0.6.4 → 0.6.5

package/dist/index.mjs

@@ -2098,6 +2098,9 @@ import {
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { NestInstrumentation } from "@opentelemetry/instrumentation-nestjs-core";
 import {
   detectResources,
   envDetector,
@@ -2112,6 +2115,7 @@ import { NodeSDK } from "@opentelemetry/sdk-node";
 import {
   BatchSpanProcessor,
   NodeTracerProvider,
+  SimpleSpanProcessor,
   TraceIdRatioBasedSampler
 } from "@opentelemetry/sdk-trace-node";
 import {
@@ -2119,6 +2123,124 @@ import {
   ATTR_SERVICE_VERSION
 } from "@opentelemetry/semantic-conventions";
 
+// src/telemetry/in-memory-exporter.ts
+import { ExportResultCode } from "@opentelemetry/core";
+var CustomInMemorySpanExporter = class {
+  spansByTraceId = /* @__PURE__ */ new Map();
+  traceDict = /* @__PURE__ */ new Map();
+  export(spans, resultCallback) {
+    for (const span of spans) {
+      const traceId = span.spanContext().traceId;
+      const existingSpans = this.spansByTraceId.get(traceId);
+      if (existingSpans) {
+        existingSpans.push(span);
+      } else {
+        this.spansByTraceId.set(traceId, [span]);
+      }
+      const sessionId = span.attributes[ADK_ATTRS.SESSION_ID];
+      if (sessionId) {
+        const existingTraces = this.traceDict.get(sessionId);
+        if (existingTraces) {
+          if (!existingTraces.includes(traceId)) {
+            existingTraces.push(traceId);
+          }
+        } else {
+          this.traceDict.set(sessionId, [traceId]);
+        }
+      }
+    }
+    resultCallback({ code: ExportResultCode.SUCCESS });
+  }
+  /**
+   * Get all finished spans
+   */
+  getFinishedSpans() {
+    const allSpans = [];
+    for (const spans of this.spansByTraceId.values()) {
+      allSpans.push(...spans);
+    }
+    return allSpans;
+  }
+  /**
+   * Get spans for a specific session (efficient)
+   */
+  getFinishedSpansForSession(sessionId) {
+    const traceIds = this.traceDict.get(sessionId);
+    if (!traceIds || traceIds.length === 0) {
+      return [];
+    }
+    const result = [];
+    for (const traceId of traceIds) {
+      const spans = this.spansByTraceId.get(traceId);
+      if (spans) {
+        result.push(...spans);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all session IDs
+   */
+  getSessionIds() {
+    return Array.from(this.traceDict.keys());
+  }
+  /**
+   * Get trace IDs for a specific session
+   */
+  getTraceIdsForSession(sessionId) {
+    return this.traceDict.get(sessionId) || [];
+  }
+  /**
+   * Force flush (no-op)
+   */
+  async forceFlush() {
+    return;
+  }
+  /**
+   * Shutdown exporter
+   */
+  async shutdown() {
+    this.clear();
+  }
+  /**
+   * Clear all stored data
+   */
+  clear() {
+    this.spansByTraceId.clear();
+    this.traceDict.clear();
+  }
+  /**
+   * Get statistics about stored data
+   */
+  getStats() {
+    let totalSpans = 0;
+    for (const spans of this.spansByTraceId.values()) {
+      totalSpans += spans.length;
+    }
+    const sessionStats = Array.from(this.traceDict.entries()).map(
+      ([sessionId, traceIds]) => {
+        let spanCount = 0;
+        for (const traceId of traceIds) {
+          const spans = this.spansByTraceId.get(traceId);
+          if (spans) {
+            spanCount += spans.length;
+          }
+        }
+        return {
+          sessionId,
+          traceCount: traceIds.length,
+          spanCount
+        };
+      }
+    );
+    return {
+      totalSpans,
+      totalSessions: this.traceDict.size,
+      sessionStats
+    };
+  }
+};
+
 // src/telemetry/utils.ts
 function shouldCaptureContent() {
   const value = process.env[ENV_VARS.CAPTURE_MESSAGE_CONTENT];
@@ -2293,9 +2415,6 @@ function validateConfig(config) {
   if (!config.appName) {
     errors.push("appName is required");
   }
-  if (!config.otlpEndpoint) {
-    errors.push("otlpEndpoint is required");
-  }
   if (config.samplingRatio !== void 0 && (config.samplingRatio < 0 || config.samplingRatio > 1)) {
     errors.push("samplingRatio must be between 0.0 and 1.0");
   }
@@ -2312,6 +2431,7 @@ var SetupService = class {
   tracerProvider = null;
   isInitialized = false;
   config = null;
+  inMemoryExporter = null;
   /**
    * Initialize OpenTelemetry with comprehensive configuration
    */
@@ -2325,6 +2445,7 @@ var SetupService = class {
       throw new Error(`Invalid telemetry configuration: ${errors.join(", ")}`);
     }
     this.config = config;
+    this.inMemoryExporter = new CustomInMemorySpanExporter();
     diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
     const resource = this.createResource(config);
     const enableTracing = config.enableTracing ?? DEFAULTS.ENABLE_TRACING;
@@ -2383,16 +2504,23 @@ var SetupService = class {
    * Initialize tracing provider
    */
   initializeTracing(config, resource) {
-    const traceExporter = new OTLPTraceExporter({
-      url: config.otlpEndpoint,
-      headers: config.otlpHeaders
-    });
-    const spanProcessor = new BatchSpanProcessor(traceExporter);
+    const spanProcessors = [];
+    if (config.otlpEndpoint) {
+      const traceExporter = new OTLPTraceExporter({
+        url: config.otlpEndpoint,
+        headers: config.otlpHeaders
+      });
+      spanProcessors.push(new BatchSpanProcessor(traceExporter));
+    }
+    if (config.debug) {
+      const inMemoryProcessor = new SimpleSpanProcessor(this.inMemoryExporter);
+      spanProcessors.push(inMemoryProcessor);
+    }
     const sampler = config.samplingRatio !== void 0 ? new TraceIdRatioBasedSampler(config.samplingRatio) : void 0;
     this.tracerProvider = new NodeTracerProvider({
       resource,
       sampler,
-      spanProcessors: [spanProcessor]
+      spanProcessors
     });
     this.tracerProvider.register();
     diag.debug("Tracing provider initialized");
@@ -2401,6 +2529,10 @@ var SetupService = class {
    * Initialize metrics provider
    */
   initializeMetrics(config, resource) {
+    if (!config.otlpEndpoint) {
+      diag.debug("Skipping metrics initialization: No otlpEndpoint provided");
+      return;
+    }
     const metricsEndpoint = config.otlpEndpoint.replace(
       "/v1/traces",
       "/v1/metrics"
@@ -2431,37 +2563,51 @@ var SetupService = class {
   async initializeAutoInstrumentation(config, resource) {
     const enableTracing = config.enableTracing ?? DEFAULTS.ENABLE_TRACING;
     const enableMetrics = config.enableMetrics ?? DEFAULTS.ENABLE_METRICS;
-    const traceExporter = enableTracing ? new OTLPTraceExporter({
+    const traceExporter = enableTracing && config.otlpEndpoint ? new OTLPTraceExporter({
       url: config.otlpEndpoint,
       headers: config.otlpHeaders
     }) : void 0;
-    const metricsEndpoint = config.otlpEndpoint.replace(
-      "/v1/traces",
-      "/v1/metrics"
-    );
-    const metricReader = enableMetrics ? new PeriodicExportingMetricReader({
-      exporter: new OTLPMetricExporter({
-        url: metricsEndpoint,
-        headers: config.otlpHeaders
-      }),
-      exportIntervalMillis: config.metricExportIntervalMs ?? DEFAULTS.METRIC_EXPORT_INTERVAL_MS
-    }) : void 0;
+    let metricReader;
+    if (enableMetrics && config.otlpEndpoint) {
+      const metricsEndpoint = config.otlpEndpoint.replace(
+        "/v1/traces",
+        "/v1/metrics"
+      );
+      metricReader = new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporter({
+          url: metricsEndpoint,
+          headers: config.otlpHeaders
+        }),
+        exportIntervalMillis: config.metricExportIntervalMs ?? DEFAULTS.METRIC_EXPORT_INTERVAL_MS
+      });
+    }
     const sampler = config.samplingRatio !== void 0 ? new TraceIdRatioBasedSampler(config.samplingRatio) : void 0;
+    const spanProcessors = [];
+    if (enableTracing && traceExporter) {
+      spanProcessors.push(new BatchSpanProcessor(traceExporter));
+    }
+    if (config.debug) {
+      spanProcessors.push(new SimpleSpanProcessor(this.inMemoryExporter));
+    }
     this.sdk = new NodeSDK({
       resource,
-      traceExporter,
+      spanProcessors: spanProcessors.length > 0 ? spanProcessors : void 0,
       metricReader,
       sampler,
       instrumentations: [
-        getNodeAutoInstrumentations({
-          // Ignore incoming HTTP requests (we're usually making outgoing calls)
+        new ExpressInstrumentation(),
+        new NestInstrumentation(),
+        new HttpInstrumentation(),
+        // Only enable auto-instrumentations when NOT in debug
+        ...!config.debug ? getNodeAutoInstrumentations({
           "@opentelemetry/instrumentation-http": {
+            // Ignore incoming HTTP requests (we're usually making outgoing calls)
             ignoreIncomingRequestHook: () => true
           }
-        })
+        }) : []
       ]
     });
-    await this.sdk.start();
+    this.sdk.start();
     diag.debug("Auto-instrumentation initialized with NodeSDK");
   }
   /**
@@ -2536,6 +2682,12 @@ var SetupService = class {
     });
     await Promise.race([Promise.all(flushPromises), timeoutPromise]);
   }
+  getInMemoryExporter() {
+    if (!this.inMemoryExporter) {
+      throw new Error("Telemetry not initialized - call initialize() first");
+    }
+    return this.inMemoryExporter;
+  }
 };
 var setupService = new SetupService();
 
@@ -3267,11 +3419,21 @@ var TelemetryService = class {
   async shutdown(timeoutMs) {
     await setupService.shutdown(timeoutMs);
   }
+  /**
+   * Get traces for a specific session (Debug/Visualization)
+   */
+  getTraces() {
+    return setupService.getInMemoryExporter().getFinishedSpans();
+  }
+  getTracesForSession(sessionId) {
+    return setupService.getInMemoryExporter().getFinishedSpansForSession(sessionId);
+  }
 };
 var telemetryService = new TelemetryService();
 var tracer = telemetryService.getTracer();
 var initializeTelemetry = (config) => telemetryService.initialize(config);
 var shutdownTelemetry = (timeoutMs) => telemetryService.shutdown(timeoutMs);
+var getTraces = () => telemetryService.getTraces();
 var traceAgentInvocation = (agent, invocationContext, input, output) => telemetryService.traceAgentInvocation(
   agent,
   invocationContext,
@@ -14583,6 +14745,12 @@ var Runner = class {
         newMessage,
         runConfig
       });
+      span.setAttribute(ADK_ATTRS.SESSION_ID, session.id);
+      span.setAttribute(ADK_ATTRS.USER_ID, userId);
+      span.setAttribute(
+        ADK_ATTRS.INVOCATION_ID,
+        invocationContext.invocationId
+      );
       if (newMessage) {
         await context3.with(
           spanContext,
@@ -19672,6 +19840,7 @@ export {
   getEnvironment,
   getLongRunningFunctionCalls,
   getMcpTools,
+  getTraces,
   handleFunctionCallsAsync,
   handleFunctionCallsLive,
   requestProcessor7 as identityRequestProcessor,

package/package.json

@@ -1,9 +1,31 @@
 {
   "name": "@iqai/adk",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Agent Development Kit for TypeScript with multi-provider LLM support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./constants": {
+      "import": {
+        "types": "./dist/constants.d.mts",
+        "default": "./dist/constants.mjs"
+      },
+      "require": {
+        "types": "./dist/constants.d.ts",
+        "default": "./dist/constants.js"
+      }
+    }
+  },
   "bin": {
     "adk": "./dist/cli/index.js"
   },
@@ -32,8 +54,11 @@
     "@modelcontextprotocol/sdk": "1.25.1",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/auto-instrumentations-node": "^0.67.3",
+    "@opentelemetry/core": "^2.3.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.208.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.208.0",
+    "@opentelemetry/instrumentation": "^0.209.0",
+    "@opentelemetry/instrumentation-openai": "^0.7.1",
     "@opentelemetry/resources": "^2.2.0",
     "@opentelemetry/sdk-metrics": "^2.2.0",
     "@opentelemetry/sdk-node": "^0.208.0",
@@ -58,12 +83,24 @@
     "zod": "^4.1.5"
   },
   "peerDependencies": {
+    "@opentelemetry/instrumentation-express": "^0.58.0",
+    "@opentelemetry/instrumentation-http": "^0.210.0",
+    "@opentelemetry/instrumentation-nestjs-core": "^0.55.0",
     "better-sqlite3": "^11.10.0",
     "langfuse": "^3.38.6",
     "mysql2": "^3.14.1",
     "pg": "^8.16.0"
   },
   "peerDependenciesMeta": {
+    "@opentelemetry/instrumentation-express": {
+      "optional": true
+    },
+    "@opentelemetry/instrumentation-http": {
+      "optional": true
+    },
+    "@opentelemetry/instrumentation-nestjs-core": {
+      "optional": true
+    },
     "better-sqlite3": {
       "optional": true
     },