@iqai/adk 0.5.9 → 0.6.0

package/dist/index.mjs

@@ -886,7 +886,7 @@ init_logger();
 import { generateId } from "ai";
 
 // src/runners.ts
-import { context as context3, SpanStatusCode, trace as trace3 } from "@opentelemetry/api";
+import { context as context3, SpanStatusCode, trace as trace4 } from "@opentelemetry/api";
 
 // src/agents/invocation-context.ts
 var LlmCallsLimitExceededError = class extends Error {
@@ -971,6 +971,11 @@ var InvocationContext = class _InvocationContext {
    * Configurations for live agents under this invocation.
    */
   runConfig;
+  /**
+   * Transfer context for multi-agent workflows
+   * Tracks agent transfer chain for telemetry
+   */
+  transferContext;
   /**
    * A container to keep track of different kinds of costs incurred as a part
    * of this invocation.
@@ -994,6 +999,7 @@ var InvocationContext = class _InvocationContext {
     this.activeStreamingTools = options.activeStreamingTools;
     this.transcriptionCache = options.transcriptionCache;
     this.runConfig = options.runConfig;
+    this.transferContext = options.transferContext;
   }
   /**
    * App name from the session
@@ -1039,7 +1045,9 @@ var InvocationContext = class _InvocationContext {
       liveRequestQueue: this.liveRequestQueue,
       activeStreamingTools: this.activeStreamingTools,
       transcriptionCache: this.transcriptionCache,
-      runConfig: this.runConfig
+      runConfig: this.runConfig,
+      transferContext: this.transferContext
+      // Propagate transfer context
     });
   }
 };
@@ -1259,288 +1267,1675 @@ var LlmResponse = class _LlmResponse {
 
 // src/models/base-llm.ts
 init_logger();
+import { trace as trace2 } from "@opentelemetry/api";
+
+// src/telemetry/metrics.ts
+import { metrics } from "@opentelemetry/api";
+
+// src/telemetry/constants.ts
+var SEMCONV = {
+  // System identification (REQUIRED)
+  GEN_AI_PROVIDER_NAME: "gen_ai.provider.name",
+  // e.g., "openai", "anthropic", "aws.bedrock"
+  // Operation names (REQUIRED)
+  GEN_AI_OPERATION_NAME: "gen_ai.operation.name",
+  // Agent attributes
+  GEN_AI_AGENT_ID: "gen_ai.agent.id",
+  // Unique agent identifier
+  GEN_AI_AGENT_NAME: "gen_ai.agent.name",
+  GEN_AI_AGENT_DESCRIPTION: "gen_ai.agent.description",
+  GEN_AI_CONVERSATION_ID: "gen_ai.conversation.id",
+  // Tool attributes
+  GEN_AI_TOOL_NAME: "gen_ai.tool.name",
+  GEN_AI_TOOL_DESCRIPTION: "gen_ai.tool.description",
+  GEN_AI_TOOL_TYPE: "gen_ai.tool.type",
+  GEN_AI_TOOL_CALL_ID: "gen_ai.tool.call.id",
+  GEN_AI_TOOL_CALL_ARGUMENTS: "gen_ai.tool.call.arguments",
+  // Structured tool input (opt-in)
+  GEN_AI_TOOL_CALL_RESULT: "gen_ai.tool.call.result",
+  // Structured tool output (opt-in)
+  GEN_AI_TOOL_DEFINITIONS: "gen_ai.tool.definitions",
+  // Tool schemas (opt-in)
+  // LLM request attributes
+  GEN_AI_REQUEST_MODEL: "gen_ai.request.model",
+  // Conditionally required
+  GEN_AI_REQUEST_MAX_TOKENS: "gen_ai.request.max_tokens",
+  GEN_AI_REQUEST_TEMPERATURE: "gen_ai.request.temperature",
+  GEN_AI_REQUEST_TOP_P: "gen_ai.request.top_p",
+  GEN_AI_REQUEST_TOP_K: "gen_ai.request.top_k",
+  GEN_AI_REQUEST_FREQUENCY_PENALTY: "gen_ai.request.frequency_penalty",
+  GEN_AI_REQUEST_PRESENCE_PENALTY: "gen_ai.request.presence_penalty",
+  GEN_AI_REQUEST_STOP_SEQUENCES: "gen_ai.request.stop_sequences",
+  GEN_AI_REQUEST_CHOICE_COUNT: "gen_ai.request.choice.count",
+  // Conditionally required (if !=1)
+  GEN_AI_REQUEST_SEED: "gen_ai.request.seed",
+  // Conditionally required
+  // LLM response attributes
+  GEN_AI_RESPONSE_ID: "gen_ai.response.id",
+  // Recommended - completion ID
+  GEN_AI_RESPONSE_MODEL: "gen_ai.response.model",
+  // Recommended - actual model name returned
+  GEN_AI_RESPONSE_FINISH_REASONS: "gen_ai.response.finish_reasons",
+  GEN_AI_OUTPUT_TYPE: "gen_ai.output.type",
+  // Conditionally required - "text", "json", "image", "speech"
+  // Token usage (input/output only; total is computed client-side)
+  GEN_AI_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+  GEN_AI_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+  // Content attributes (opt-in, large/PII)
+  GEN_AI_SYSTEM_INSTRUCTIONS: "gen_ai.system_instructions",
+  // System prompt
+  GEN_AI_INPUT_MESSAGES: "gen_ai.input.messages",
+  // Full chat history input
+  GEN_AI_OUTPUT_MESSAGES: "gen_ai.output.messages",
+  // Model output messages
+  // Server attributes (Recommended)
+  SERVER_ADDRESS: "server.address",
+  // GenAI server host
+  SERVER_PORT: "server.port",
+  // Conditionally required if server.address is set
+  // Error attributes (Conditionally required on error)
+  ERROR_TYPE: "error.type",
+  // Low-cardinality error identifier
+  // Data source (for RAG/knowledge base)
+  GEN_AI_DATA_SOURCE_ID: "gen_ai.data_source.id",
+  // Embeddings (for future support)
+  GEN_AI_EMBEDDINGS_DIMENSION_COUNT: "gen_ai.embeddings.dimension.count",
+  GEN_AI_REQUEST_ENCODING_FORMATS: "gen_ai.request.encoding_formats",
+  // ============================================
+  // DEPRECATED ATTRIBUTES (kept for backward compatibility)
+  // These will be removed in a future release
+  // ============================================
+  /**
+   * @deprecated Use GEN_AI_PROVIDER_NAME instead
+   */
+  GEN_AI_SYSTEM: "gen_ai.system",
+  /**
+   * @deprecated Total tokens should be computed client-side from input + output
+   */
+  GEN_AI_USAGE_TOTAL_TOKENS: "gen_ai.usage.total_tokens",
+  /**
+   * @deprecated Use GEN_AI_INPUT_MESSAGES or structured events instead
+   */
+  GEN_AI_CONTENT_PROMPT: "gen_ai.content.prompt",
+  /**
+   * @deprecated Use GEN_AI_OUTPUT_MESSAGES or structured events instead
+   */
+  GEN_AI_CONTENT_COMPLETION: "gen_ai.content.completion"
+};
+var ADK_ATTRS = {
+  // ============================================
+  // TIER 1: Always Present (Core Identity)
+  // ============================================
+  // System identification
+  SYSTEM_NAME: "adk.system.name",
+  SYSTEM_VERSION: "adk.system.version",
+  // Session and context
+  SESSION_ID: "adk.session.id",
+  USER_ID: "adk.user.id",
+  INVOCATION_ID: "adk.invocation.id",
+  EVENT_ID: "adk.event.id",
+  // Environment
+  ENVIRONMENT: "adk.environment",
+  // ============================================
+  // TIER 2: Operation-Specific (Standard)
+  // ============================================
+  // Agent attributes
+  AGENT_NAME: "adk.agent.name",
+  AGENT_DESCRIPTION: "adk.agent.description",
+  // Transfer attributes (for multi-agent)
+  TRANSFER_SOURCE_AGENT: "adk.transfer.source_agent",
+  TRANSFER_TARGET_AGENT: "adk.transfer.target_agent",
+  TRANSFER_CHAIN: "adk.transfer.chain",
+  TRANSFER_DEPTH: "adk.transfer.depth",
+  TRANSFER_ROOT_AGENT: "adk.transfer.root_agent",
+  TRANSFER_REASON: "adk.transfer.reason",
+  // Tool attributes
+  TOOL_NAME: "adk.tool.name",
+  TOOL_ARGS: "adk.tool.args",
+  TOOL_RESPONSE: "adk.tool.response",
+  TOOL_EXECUTION_ORDER: "adk.tool.execution_order",
+  TOOL_PARALLEL_GROUP: "adk.tool.parallel_group",
+  TOOL_RETRY_COUNT: "adk.tool.retry_count",
+  TOOL_IS_CALLBACK_OVERRIDE: "adk.tool.is_callback_override",
+  // LLM attributes
+  LLM_MODEL: "adk.llm.model",
+  LLM_REQUEST: "adk.llm.request",
+  LLM_RESPONSE: "adk.llm.response",
+  LLM_STREAMING: "adk.llm.streaming",
+  LLM_TIME_TO_FIRST_TOKEN: "adk.llm.time_to_first_token_ms",
+  LLM_CHUNK_COUNT: "adk.llm.chunk_count",
+  LLM_CACHED_TOKENS: "adk.llm.cached_tokens",
+  LLM_CONTEXT_WINDOW_USED_PCT: "adk.llm.context_window_used_pct",
+  // Callback attributes
+  CALLBACK_TYPE: "adk.callback.type",
+  CALLBACK_NAME: "adk.callback.name",
+  CALLBACK_INDEX: "adk.callback.index",
+  // ============================================
+  // Error Categorization
+  // ============================================
+  ERROR_CATEGORY: "adk.error.category",
+  ERROR_RECOVERABLE: "adk.error.recoverable",
+  ERROR_RETRY_RECOMMENDED: "adk.error.retry_recommended",
+  // ============================================
+  // Memory & Session
+  // ============================================
+  MEMORY_QUERY: "adk.memory.query",
+  MEMORY_RESULTS_COUNT: "adk.memory.results_count",
+  // Plugin
+  PLUGIN_NAME: "adk.plugin.name",
+  PLUGIN_HOOK: "adk.plugin.hook"
+};
+var OPERATIONS = {
+  // ============================================
+  // Standard OpenTelemetry GenAI operations
+  // ============================================
+  CHAT: "chat",
+  // Chat completion (most common)
+  TEXT_COMPLETION: "text_completion",
+  // Legacy text completion
+  GENERATE_CONTENT: "generate_content",
+  // Generic content generation
+  // Agent operations
+  INVOKE_AGENT: "invoke_agent",
+  CREATE_AGENT: "create_agent",
+  // Tool operations
+  EXECUTE_TOOL: "execute_tool",
+  // ============================================
+  // ADK-specific operations (framework extensions)
+  // These are non-standard but useful for the ADK framework
+  // ============================================
+  TRANSFER_AGENT: "transfer_agent",
+  // Multi-agent transfer
+  EXECUTE_CALLBACK: "execute_callback",
+  // Callback execution
+  // Service operations
+  SEARCH_MEMORY: "search_memory",
+  // Memory search
+  INSERT_MEMORY: "insert_memory",
+  // Memory insert
+  EXECUTE_PLUGIN: "execute_plugin",
+  // Plugin execution
+  // ============================================
+  // DEPRECATED OPERATIONS (kept for backward compatibility)
+  // ============================================
+  /**
+   * @deprecated Use CHAT, TEXT_COMPLETION, or GENERATE_CONTENT instead
+   */
+  CALL_LLM: "call_llm"
+};
+var ADK_SYSTEM_NAME = "iqai-adk";
+var ENV_VARS = {
+  // Privacy control
+  CAPTURE_MESSAGE_CONTENT: "ADK_CAPTURE_MESSAGE_CONTENT",
+  // OpenTelemetry standard env vars
+  OTEL_SERVICE_NAME: "OTEL_SERVICE_NAME",
+  OTEL_RESOURCE_ATTRIBUTES: "OTEL_RESOURCE_ATTRIBUTES",
+  OTEL_EXPORTER_OTLP_ENDPOINT: "OTEL_EXPORTER_OTLP_ENDPOINT",
+  OTEL_EXPORTER_OTLP_HEADERS: "OTEL_EXPORTER_OTLP_HEADERS",
+  // Node environment
+  NODE_ENV: "NODE_ENV"
+};
+var METRICS = {
+  // ============================================
+  // Standard OpenTelemetry GenAI Metrics
+  // Reference: https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/
+  // ============================================
+  // Required: Client operation duration (Histogram, seconds)
+  GEN_AI_CLIENT_OPERATION_DURATION: "gen_ai.client.operation.duration",
+  // Recommended: Token usage (Histogram, tokens)
+  // Use with gen_ai.token.type attribute: "input" or "output"
+  GEN_AI_CLIENT_TOKEN_USAGE: "gen_ai.client.token.usage",
+  // Server-side metrics (if hosting GenAI service)
+  GEN_AI_SERVER_REQUEST_DURATION: "gen_ai.server.request.duration",
+  GEN_AI_SERVER_TIME_TO_FIRST_TOKEN: "gen_ai.server.time_to_first_token",
+  GEN_AI_SERVER_TIME_PER_OUTPUT_TOKEN: "gen_ai.server.time_per_output_token",
+  // ============================================
+  // ADK-specific Metrics (framework extensions)
+  // ============================================
+  // Counters
+  AGENT_INVOCATIONS: "adk.agent.invocations",
+  TOOL_EXECUTIONS: "adk.tool.executions",
+  LLM_CALLS: "adk.llm.calls",
+  ERRORS: "adk.errors",
+  // Histograms
+  AGENT_DURATION: "adk.agent.duration",
+  TOOL_DURATION: "adk.tool.duration",
+  LLM_DURATION: "adk.llm.duration",
+  LLM_TOKENS: "adk.llm.tokens",
+  LLM_INPUT_TOKENS: "adk.llm.tokens.input",
+  LLM_OUTPUT_TOKENS: "adk.llm.tokens.output"
+};
+var SPAN_STATUS = {
+  UNSET: 0,
+  OK: 1,
+  ERROR: 2
+};
+var DEFAULTS = {
+  SAMPLING_RATIO: 1,
+  METRIC_EXPORT_INTERVAL_MS: 6e4,
+  // 1 minute
+  SHUTDOWN_TIMEOUT_MS: 5e3,
+  CAPTURE_MESSAGE_CONTENT: true,
+  ENABLE_TRACING: true,
+  ENABLE_METRICS: true,
+  ENABLE_AUTO_INSTRUMENTATION: true
+};
+
+// src/telemetry/metrics.ts
+var MetricsService = class {
+  meter = null;
+  // Counters
+  agentInvocationsCounter = null;
+  toolExecutionsCounter = null;
+  llmCallsCounter = null;
+  errorsCounter = null;
+  // Histograms
+  agentDurationHistogram = null;
+  toolDurationHistogram = null;
+  llmDurationHistogram = null;
+  llmTokensHistogram = null;
+  llmInputTokensHistogram = null;
+  llmOutputTokensHistogram = null;
+  /**
+   * Initialize metrics with the provided meter
+   */
+  initialize(meterName, version) {
+    this.meter = metrics.getMeter(meterName, version);
+    this.createMetrics();
+  }
+  /**
+   * Check if metrics are initialized
+   */
+  get initialized() {
+    return this.meter !== null;
+  }
+  /**
+   * Create all metric instruments
+   */
+  createMetrics() {
+    if (!this.meter) return;
+    this.agentInvocationsCounter = this.meter.createCounter(
+      METRICS.AGENT_INVOCATIONS,
+      {
+        description: "Total number of agent invocations",
+        unit: "1"
+      }
+    );
+    this.toolExecutionsCounter = this.meter.createCounter(
+      METRICS.TOOL_EXECUTIONS,
+      {
+        description: "Total number of tool executions",
+        unit: "1"
+      }
+    );
+    this.llmCallsCounter = this.meter.createCounter(METRICS.LLM_CALLS, {
+      description: "Total number of LLM calls",
+      unit: "1"
+    });
+    this.errorsCounter = this.meter.createCounter(METRICS.ERRORS, {
+      description: "Total number of errors",
+      unit: "1"
+    });
+    this.agentDurationHistogram = this.meter.createHistogram(
+      METRICS.AGENT_DURATION,
+      {
+        description: "Duration of agent invocations",
+        unit: "ms"
+      }
+    );
+    this.toolDurationHistogram = this.meter.createHistogram(
+      METRICS.TOOL_DURATION,
+      {
+        description: "Duration of tool executions",
+        unit: "ms"
+      }
+    );
+    this.llmDurationHistogram = this.meter.createHistogram(
+      METRICS.LLM_DURATION,
+      {
+        description: "Duration of LLM calls",
+        unit: "ms"
+      }
+    );
+    this.llmTokensHistogram = this.meter.createHistogram(METRICS.LLM_TOKENS, {
+      description: "Total tokens used in LLM calls",
+      unit: "1"
+    });
+    this.llmInputTokensHistogram = this.meter.createHistogram(
+      METRICS.LLM_INPUT_TOKENS,
+      {
+        description: "Input tokens used in LLM calls",
+        unit: "1"
+      }
+    );
+    this.llmOutputTokensHistogram = this.meter.createHistogram(
+      METRICS.LLM_OUTPUT_TOKENS,
+      {
+        description: "Output tokens generated by LLM calls",
+        unit: "1"
+      }
+    );
+  }
+  /**
+   * Record an agent invocation
+   */
+  recordAgentInvocation(dimensions) {
+    if (!this.agentInvocationsCounter) return;
+    const attributes = {
+      "agent.name": dimensions.agentName,
+      status: dimensions.status
+    };
+    if (dimensions.environment) {
+      attributes.environment = dimensions.environment;
+    }
+    this.agentInvocationsCounter.add(1, attributes);
+  }
+  /**
+   * Record agent execution duration
+   */
+  recordAgentDuration(durationMs, dimensions) {
+    if (!this.agentDurationHistogram) return;
+    const attributes = {
+      "agent.name": dimensions.agentName,
+      status: dimensions.status
+    };
+    if (dimensions.environment) {
+      attributes.environment = dimensions.environment;
+    }
+    this.agentDurationHistogram.record(durationMs, attributes);
+  }
+  /**
+   * Record a tool execution
+   */
+  recordToolExecution(dimensions) {
+    if (!this.toolExecutionsCounter) return;
+    const attributes = {
+      "tool.name": dimensions.toolName,
+      status: dimensions.status
+    };
+    if (dimensions.agentName) {
+      attributes["agent.name"] = dimensions.agentName;
+    }
+    if (dimensions.environment) {
+      attributes.environment = dimensions.environment;
+    }
+    this.toolExecutionsCounter.add(1, attributes);
+  }
+  /**
+   * Record tool execution duration
+   */
+  recordToolDuration(durationMs, dimensions) {
+    if (!this.toolDurationHistogram) return;
+    const attributes = {
+      "tool.name": dimensions.toolName,
+      status: dimensions.status
+    };
+    if (dimensions.agentName) {
+      attributes["agent.name"] = dimensions.agentName;
+    }
+    if (dimensions.environment) {
+      attributes.environment = dimensions.environment;
+    }
+    this.toolDurationHistogram.record(durationMs, attributes);
+  }
+  /**
+   * Record an LLM call
+   */
+  recordLlmCall(dimensions) {
+    if (!this.llmCallsCounter) return;
+    const attributes = {
+      model: dimensions.model,
+      status: dimensions.status
+    };
+    if (dimensions.agentName) {
+      attributes["agent.name"] = dimensions.agentName;
+    }
+    if (dimensions.environment) {
+      attributes.environment = dimensions.environment;
+    }
+    this.llmCallsCounter.add(1, attributes);
+  }
+  /**
+   * Record LLM call duration
+   */
+  recordLlmDuration(durationMs, dimensions) {
+    if (!this.llmDurationHistogram) return;
+    const attributes = {
+      model: dimensions.model,
+      status: dimensions.status
+    };
+    if (dimensions.agentName) {
+      attributes["agent.name"] = dimensions.agentName;
+    }
+    if (dimensions.environment) {
+      attributes.environment = dimensions.environment;
+    }
+    this.llmDurationHistogram.record(durationMs, attributes);
+  }
+  /**
+   * Record LLM token usage
+   */
+  recordLlmTokens(inputTokens, outputTokens, dimensions) {
+    if (!this.llmTokensHistogram || !this.llmInputTokensHistogram || !this.llmOutputTokensHistogram) {
+      return;
+    }
+    const attributes = {
+      model: dimensions.model,
+      status: dimensions.status
+    };
+    if (dimensions.agentName) {
+      attributes["agent.name"] = dimensions.agentName;
+    }
+    if (dimensions.environment) {
+      attributes.environment = dimensions.environment;
+    }
+    const totalTokens = inputTokens + outputTokens;
+    this.llmTokensHistogram.record(totalTokens, attributes);
+    this.llmInputTokensHistogram.record(inputTokens, attributes);
+    this.llmOutputTokensHistogram.record(outputTokens, attributes);
+  }
+  /**
+   * Record an error
+   */
+  recordError(errorType, context4) {
+    if (!this.errorsCounter) return;
+    this.errorsCounter.add(1, {
+      error_type: errorType,
+      context: context4
+    });
+  }
+};
+var metricsService = new MetricsService();
 
-// src/telemetry.ts
+// src/telemetry/setup.ts
 import {
-  context,
   DiagConsoleLogger,
   DiagLogLevel,
   diag,
-  trace
+  metrics as metrics2
 } from "@opentelemetry/api";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  detectResources,
+  envDetector,
+  processDetector,
+  resourceFromAttributes
+} from "@opentelemetry/resources";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
 import { NodeSDK } from "@opentelemetry/sdk-node";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider,
+  TraceIdRatioBasedSampler
+} from "@opentelemetry/sdk-trace-node";
 import {
   ATTR_SERVICE_NAME,
   ATTR_SERVICE_VERSION
 } from "@opentelemetry/semantic-conventions";
-var TelemetryService = class {
+
+// src/telemetry/utils.ts
+function shouldCaptureContent() {
+  const value = process.env[ENV_VARS.CAPTURE_MESSAGE_CONTENT];
+  if (value === void 0) {
+    return DEFAULTS.CAPTURE_MESSAGE_CONTENT;
+  }
+  return value === "true" || value === "1" || value === "yes";
+}
+function extractTextFromContent(content) {
+  if (!content) return "";
+  const parts = "parts" in content ? content.parts : void 0;
+  if (!parts || !Array.isArray(parts)) return "";
+  return parts.map(
+    (part) => part && typeof part === "object" && "text" in part ? part.text : ""
+  ).join("").trim();
+}
+function safeJsonStringify(obj) {
+  try {
+    return JSON.stringify(obj);
+  } catch {
+    return "<serialization_failed>";
+  }
+}
+function parseResourceAttributes(envValue) {
+  if (!envValue) {
+    return {};
+  }
+  const attributes = {};
+  try {
+    const pairs = envValue.split(",");
+    for (const pair of pairs) {
+      const [key, value] = pair.split("=");
+      if (key && value) {
+        attributes[key.trim()] = value.trim();
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to parse OTEL_RESOURCE_ATTRIBUTES:", error);
+  }
+  return attributes;
+}
+function getEnvironment() {
+  return process.env[ENV_VARS.NODE_ENV];
+}
+function detectProvider(model) {
+  const lowerModel = model.toLowerCase();
+  if (lowerModel.startsWith("gpt-") || lowerModel.startsWith("o1-") || lowerModel.startsWith("text-") || lowerModel.startsWith("davinci-") || lowerModel.startsWith("curie-") || lowerModel.startsWith("babbage-") || lowerModel.startsWith("ada-")) {
+    return "openai";
+  }
+  if (lowerModel.startsWith("claude-")) {
+    return "anthropic";
+  }
+  if (lowerModel.startsWith("gemini-") || lowerModel.startsWith("palm-") || lowerModel.startsWith("text-bison") || lowerModel.startsWith("chat-bison")) {
+    return "gcp.gemini";
+  }
+  if (lowerModel.includes("bedrock") || lowerModel.startsWith("amazon.") || lowerModel.startsWith("anthropic.claude") || lowerModel.startsWith("ai21.") || lowerModel.startsWith("cohere.") || lowerModel.startsWith("meta.llama")) {
+    return "aws.bedrock";
+  }
+  if (lowerModel.includes("azure") && !lowerModel.includes("openai")) {
+    return "azure.ai.inference";
+  }
+  if (lowerModel.startsWith("mistral-") || lowerModel.startsWith("mixtral-") || lowerModel.startsWith("codestral-")) {
+    return "mistral_ai";
+  }
+  if (lowerModel.includes("groq")) {
+    return "groq";
+  }
+  if (lowerModel.startsWith("command-") || lowerModel.startsWith("embed-") || lowerModel.includes("cohere")) {
+    return "cohere";
+  }
+  if (lowerModel.startsWith("deepseek-")) {
+    return "deepseek";
+  }
+  if (lowerModel.startsWith("grok-")) {
+    return "x_ai";
+  }
+  if (lowerModel.startsWith("pplx-") || lowerModel.startsWith("llama-3.1-sonar") || lowerModel.includes("perplexity")) {
+    return "perplexity";
+  }
+  if (lowerModel.includes("watsonx") || lowerModel.startsWith("ibm/")) {
+    return "ibm.watsonx.ai";
+  }
+  if (lowerModel.startsWith("llama-") || lowerModel.startsWith("meta-llama")) {
+    return "meta";
+  }
+  if (lowerModel.includes("ollama")) {
+    return "ollama";
+  }
+  if (lowerModel.includes("huggingface") || lowerModel.includes("hf/")) {
+    return "huggingface";
+  }
+  return "unknown";
+}
+function extractFinishReason(llmResponse) {
+  if (llmResponse.finishReason) {
+    return String(llmResponse.finishReason);
+  }
+  if (llmResponse.candidates?.[0]?.finishReason) {
+    return String(llmResponse.candidates[0].finishReason);
+  }
+  return void 0;
+}
+function buildLlmRequestForTrace(llmRequest, includeContent = true) {
+  const result = {
+    model: llmRequest.model,
+    config: excludeNonSerializableFromConfig(llmRequest.config || {})
+  };
+  if (includeContent && llmRequest.contents) {
+    result.contents = llmRequest.contents.map((content) => ({
+      role: content.role,
+      parts: content.parts?.filter((part) => !part.inlineData) || []
+    }));
+  }
+  return result;
+}
+function excludeNonSerializableFromConfig(config) {
+  const result = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "response_schema" || key === "responseSchema") {
+      continue;
+    }
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (key === "functions" && Array.isArray(value)) {
+      result[key] = value.map((func) => ({
+        name: func.name,
+        description: func.description,
+        parameters: func.parameters
+      }));
+    } else if (typeof value !== "function") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function buildLlmResponseForTrace(llmResponse, includeContent = true) {
+  const result = {};
+  if (llmResponse.usageMetadata) {
+    result.usageMetadata = llmResponse.usageMetadata;
+  }
+  const finishReason = extractFinishReason(llmResponse);
+  if (finishReason) {
+    result.finishReason = finishReason;
+  }
+  if (includeContent && llmResponse.content) {
+    result.content = llmResponse.content;
+  }
+  return result;
+}
+function formatSpanAttributes(attributes) {
+  const formatted = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      formatted[key] = value;
+    } else if (Array.isArray(value)) {
+      formatted[key] = value.map((v) => String(v));
+    } else if (typeof value === "object") {
+      formatted[key] = safeJsonStringify(value);
+    }
+  }
+  return formatted;
+}
+function getServiceName(configName) {
+  return process.env[ENV_VARS.OTEL_SERVICE_NAME] || configName || "iqai-adk-app";
+}
+function validateConfig(config) {
+  const errors = [];
+  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");
+  }
+  if (config.metricExportIntervalMs !== void 0 && config.metricExportIntervalMs < 1e3) {
+    errors.push("metricExportIntervalMs must be at least 1000ms");
+  }
+  return errors;
+}
+
+// src/telemetry/setup.ts
+var SetupService = class {
   sdk = null;
+  meterProvider = null;
+  tracerProvider = null;
   isInitialized = false;
-  tracer;
   config = null;
-  constructor() {
-    this.tracer = trace.getTracer("iqai-adk", "0.1.0");
+  /**
+   * Initialize OpenTelemetry with comprehensive configuration
+   */
+  async initialize(config) {
+    if (this.isInitialized) {
+      diag.warn("Telemetry is already initialized. Skipping.");
+      return;
+    }
+    const errors = validateConfig(config);
+    if (errors.length > 0) {
+      throw new Error(`Invalid telemetry configuration: ${errors.join(", ")}`);
+    }
+    this.config = config;
+    diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+    const resource = this.createResource(config);
+    const enableTracing = config.enableTracing ?? DEFAULTS.ENABLE_TRACING;
+    const enableMetrics = config.enableMetrics ?? DEFAULTS.ENABLE_METRICS;
+    const enableAutoInstrumentation = config.enableAutoInstrumentation ?? DEFAULTS.ENABLE_AUTO_INSTRUMENTATION;
+    try {
+      if (enableAutoInstrumentation) {
+        await this.initializeAutoInstrumentation(config, resource);
+      } else {
+        if (enableTracing) {
+          this.initializeTracing(config, resource);
+        }
+        if (enableMetrics) {
+          this.initializeMetrics(config, resource);
+        }
+      }
+      this.isInitialized = true;
+      diag.info(
+        `Telemetry initialized successfully for ${config.appName} v${config.appVersion || "unknown"}`
+      );
+    } catch (error) {
+      diag.error("Error initializing telemetry:", error);
+      throw error;
+    }
+  }
+  /**
+   * Create OpenTelemetry resource with auto-detection
+   */
+  createResource(config) {
+    const detectedResource = detectResources({
+      detectors: [envDetector, processDetector]
+    });
+    const customAttributes = {
+      [ATTR_SERVICE_NAME]: getServiceName(config.appName),
+      [ATTR_SERVICE_VERSION]: config.appVersion || "unknown",
+      [ADK_ATTRS.SYSTEM_NAME]: ADK_SYSTEM_NAME,
+      [ADK_ATTRS.SYSTEM_VERSION]: config.appVersion || "unknown"
+    };
+    const environment = config.environment || getEnvironment();
+    if (environment) {
+      customAttributes[ADK_ATTRS.ENVIRONMENT] = environment;
+      customAttributes["deployment.environment.name"] = environment;
+    }
+    if (config.resourceAttributes) {
+      Object.assign(customAttributes, config.resourceAttributes);
+    }
+    const envAttributes = parseResourceAttributes(
+      process.env[ENV_VARS.OTEL_RESOURCE_ATTRIBUTES]
+    );
+    Object.assign(customAttributes, envAttributes);
+    const customResource = resourceFromAttributes(customAttributes);
+    return detectedResource.merge(customResource);
+  }
+  /**
+   * Initialize tracing provider
+   */
+  initializeTracing(config, resource) {
+    const traceExporter = new OTLPTraceExporter({
+      url: config.otlpEndpoint,
+      headers: config.otlpHeaders
+    });
+    const spanProcessor = new BatchSpanProcessor(traceExporter);
+    const sampler = config.samplingRatio !== void 0 ? new TraceIdRatioBasedSampler(config.samplingRatio) : void 0;
+    this.tracerProvider = new NodeTracerProvider({
+      resource,
+      sampler,
+      spanProcessors: [spanProcessor]
+    });
+    this.tracerProvider.register();
+    diag.debug("Tracing provider initialized");
+  }
+  /**
+   * Initialize metrics provider
+   */
+  initializeMetrics(config, resource) {
+    const metricsEndpoint = config.otlpEndpoint.replace(
+      "/v1/traces",
+      "/v1/metrics"
+    );
+    if (config.otlpEndpoint.includes("localhost:4318") || config.otlpEndpoint.includes("jaeger")) {
+      diag.warn(
+        "Jaeger typically only supports traces, not metrics. Consider using Prometheus or a full OTLP backend for metrics."
+      );
+    }
+    const metricExporter = new OTLPMetricExporter({
+      url: metricsEndpoint,
+      headers: config.otlpHeaders
+    });
+    const metricReader = new PeriodicExportingMetricReader({
+      exporter: metricExporter,
+      exportIntervalMillis: config.metricExportIntervalMs ?? DEFAULTS.METRIC_EXPORT_INTERVAL_MS
+    });
+    this.meterProvider = new MeterProvider({
+      resource,
+      readers: [metricReader]
+    });
+    metrics2.setGlobalMeterProvider(this.meterProvider);
+    diag.debug("Metrics provider initialized");
+  }
+  /**
+   * Initialize NodeSDK for auto-instrumentation
+   */
+  async initializeAutoInstrumentation(config, resource) {
+    const enableTracing = config.enableTracing ?? DEFAULTS.ENABLE_TRACING;
+    const enableMetrics = config.enableMetrics ?? DEFAULTS.ENABLE_METRICS;
+    const traceExporter = enableTracing ? 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;
+    const sampler = config.samplingRatio !== void 0 ? new TraceIdRatioBasedSampler(config.samplingRatio) : void 0;
+    this.sdk = new NodeSDK({
+      resource,
+      traceExporter,
+      metricReader,
+      sampler,
+      instrumentations: [
+        getNodeAutoInstrumentations({
+          // Ignore incoming HTTP requests (we're usually making outgoing calls)
+          "@opentelemetry/instrumentation-http": {
+            ignoreIncomingRequestHook: () => true
+          }
+        })
+      ]
+    });
+    await this.sdk.start();
+    diag.debug("Auto-instrumentation initialized with NodeSDK");
+  }
+  /**
+   * Check if telemetry is initialized
+   */
+  get initialized() {
+    return this.isInitialized;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Shutdown telemetry with timeout
+   */
+  async shutdown(timeoutMs) {
+    const timeout = timeoutMs ?? DEFAULTS.SHUTDOWN_TIMEOUT_MS;
+    if (!this.isInitialized) {
+      diag.warn("Telemetry is not initialized or already shut down.");
+      return;
+    }
+    try {
+      const shutdownPromises = [];
+      if (this.sdk) {
+        shutdownPromises.push(this.sdk.shutdown());
+      }
+      if (this.tracerProvider) {
+        shutdownPromises.push(this.tracerProvider.shutdown());
+      }
+      if (this.meterProvider) {
+        shutdownPromises.push(this.meterProvider.shutdown());
+      }
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(
+          () => reject(new Error(`Telemetry shutdown timeout after ${timeout}ms`)),
+          timeout
+        );
+      });
+      await Promise.race([Promise.all(shutdownPromises), timeoutPromise]);
+      this.isInitialized = false;
+      this.sdk = null;
+      this.tracerProvider = null;
+      this.meterProvider = null;
+      diag.info("Telemetry shut down successfully");
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timeout")) {
+        diag.warn("Telemetry shutdown timed out, some data may be lost");
+      } else {
+        diag.error("Error shutting down telemetry:", error);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Force flush all pending telemetry data
+   */
+  async flush(timeoutMs = 5e3) {
+    const flushPromises = [];
+    if (this.tracerProvider) {
+      flushPromises.push(this.tracerProvider.forceFlush());
+    }
+    if (this.meterProvider) {
+      flushPromises.push(this.meterProvider.forceFlush());
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`Flush timeout after ${timeoutMs}ms`)),
+        timeoutMs
+      );
+    });
+    await Promise.race([Promise.all(flushPromises), timeoutPromise]);
+  }
+};
+var setupService = new SetupService();
+
+// src/telemetry/tracing.ts
+import { context, trace } from "@opentelemetry/api";
+var TracingService = class {
+  tracer = null;
+  /**
+   * Initialize tracing with the provided tracer
+   */
+  initialize(tracerName, version) {
+    this.tracer = trace.getTracer(tracerName, version);
+  }
+  /**
+   * Get the current tracer instance
+   */
+  getTracer() {
+    if (!this.tracer) {
+      return trace.getTracer("iqai-adk", "0.0.0");
+    }
+    return this.tracer;
+  }
+  /**
+   * Check if tracing is initialized
+   */
+  get initialized() {
+    return this.tracer !== null;
+  }
+  /**
+   * Get the currently active span, or undefined if none
+   * Use this for conditional span operations
+   */
+  getActiveSpan() {
+    return trace.getActiveSpan();
+  }
+  /**
+   * Build common invocation context attributes
+   * Reduces duplication across tracing methods
+   */
+  buildInvocationContextAttrs(invocationContext) {
+    if (!invocationContext) return {};
+    return {
+      [ADK_ATTRS.SESSION_ID]: invocationContext.session.id,
+      [ADK_ATTRS.USER_ID]: invocationContext.userId || "",
+      [ADK_ATTRS.INVOCATION_ID]: invocationContext.invocationId
+    };
+  }
+  /**
+   * Set attributes on span with content capture check
+   * Helper to reduce boilerplate for optional content attributes
+   */
+  setContentAttributes(span, inputKey, inputValue, outputKey, outputValue, eventPrefix) {
+    if (!shouldCaptureContent()) return;
+    if (inputValue !== void 0) {
+      const inputStr = typeof inputValue === "string" ? inputValue : safeJsonStringify(inputValue);
+      span.setAttribute(inputKey, inputStr);
+      span.addEvent(`${eventPrefix}.input`, { "gen_ai.input": inputStr });
+    }
+    if (outputValue !== void 0) {
+      const outputStr = typeof outputValue === "string" ? outputValue : safeJsonStringify(outputValue);
+      span.setAttribute(outputKey, outputStr);
+      span.addEvent(`${eventPrefix}.output`, { "gen_ai.output": outputStr });
+    }
+  }
+  /**
+   * Trace an agent invocation
+   * Sets standard OpenTelemetry GenAI attributes for agents
+   */
+  traceAgentInvocation(agent, invocationContext, input, output) {
+    const span = this.getActiveSpan();
+    if (!span) return;
+    const agentId = `${agent.name}-${invocationContext.session.id}`;
+    const attributes = formatSpanAttributes({
+      // Standard GenAI attributes
+      [SEMCONV.GEN_AI_PROVIDER_NAME]: "iqai-adk",
+      [SEMCONV.GEN_AI_OPERATION_NAME]: OPERATIONS.INVOKE_AGENT,
+      [SEMCONV.GEN_AI_AGENT_ID]: agentId,
+      [SEMCONV.GEN_AI_AGENT_NAME]: agent.name,
+      [SEMCONV.GEN_AI_AGENT_DESCRIPTION]: agent.description || "",
+      [SEMCONV.GEN_AI_CONVERSATION_ID]: invocationContext.session.id,
+      // ADK-specific attributes
+      [ADK_ATTRS.AGENT_NAME]: agent.name,
+      [ADK_ATTRS.ENVIRONMENT]: getEnvironment() || "",
+      ...this.buildInvocationContextAttrs(invocationContext)
+    });
+    span.setAttributes(attributes);
+    this.setContentAttributes(
+      span,
+      SEMCONV.GEN_AI_INPUT_MESSAGES,
+      input,
+      SEMCONV.GEN_AI_OUTPUT_MESSAGES,
+      output,
+      "gen_ai.agent"
+    );
+  }
+  /**
+   * Trace a tool call
+   * Sets standard OpenTelemetry GenAI attributes for tool execution
+   */
+  traceToolCall(tool, args, functionResponseEvent, llmRequest, invocationContext) {
+    const span = this.getActiveSpan();
+    if (!span) return;
+    const functionResponse = functionResponseEvent.content?.parts?.[0]?.functionResponse;
+    const toolCallId = functionResponse?.id || "<not_specified>";
+    const toolResponse = functionResponse?.response || "<not_specified>";
+    const captureContent = shouldCaptureContent();
+    const argsJson = safeJsonStringify(args);
+    const responseJson = safeJsonStringify(toolResponse);
+    const attributes = formatSpanAttributes({
+      // Standard GenAI attributes
+      [SEMCONV.GEN_AI_PROVIDER_NAME]: "iqai-adk",
+      [SEMCONV.GEN_AI_OPERATION_NAME]: OPERATIONS.EXECUTE_TOOL,
+      [SEMCONV.GEN_AI_TOOL_NAME]: tool.name,
+      [SEMCONV.GEN_AI_TOOL_DESCRIPTION]: tool.description || "",
+      [SEMCONV.GEN_AI_TOOL_TYPE]: tool.constructor.name,
+      [SEMCONV.GEN_AI_TOOL_CALL_ID]: toolCallId,
+      // ADK-specific attributes
+      [ADK_ATTRS.TOOL_NAME]: tool.name,
+      [ADK_ATTRS.EVENT_ID]: functionResponseEvent.invocationId,
+      [ADK_ATTRS.ENVIRONMENT]: getEnvironment() || "",
+      ...this.buildInvocationContextAttrs(invocationContext)
+    });
+    span.setAttributes(attributes);
+    if (captureContent) {
+      span.setAttribute(SEMCONV.GEN_AI_TOOL_CALL_ARGUMENTS, argsJson);
+      span.setAttribute(SEMCONV.GEN_AI_TOOL_CALL_RESULT, responseJson);
+      span.setAttribute(ADK_ATTRS.TOOL_ARGS, argsJson);
+      span.setAttribute(ADK_ATTRS.TOOL_RESPONSE, responseJson);
+      span.addEvent("gen_ai.tool.input", { "gen_ai.tool.input": argsJson });
+      span.addEvent("gen_ai.tool.output", {
+        "gen_ai.tool.output": responseJson
+      });
+      if (llmRequest) {
+        const llmRequestData = buildLlmRequestForTrace(llmRequest, true);
+        span.setAttribute(
+          ADK_ATTRS.LLM_REQUEST,
+          safeJsonStringify(llmRequestData)
+        );
+      }
+    }
+  }
+  /**
+   * Trace an LLM call
+   * Sets standard OpenTelemetry GenAI attributes for LLM requests/responses
+   */
+  traceLlmCall(invocationContext, eventId, llmRequest, llmResponse) {
+    const span = trace.getActiveSpan();
+    if (!span) return;
+    const captureContent = shouldCaptureContent();
+    const llmRequestData = buildLlmRequestForTrace(llmRequest, captureContent);
+    const llmResponseData = buildLlmResponseForTrace(
+      llmResponse,
+      captureContent
+    );
+    const finishReason = extractFinishReason(llmResponse);
+    const provider = detectProvider(llmRequest.model || "");
+    const responseId = llmResponse.id;
+    let outputType = "text";
+    if (llmRequest.config?.responseSchema) {
+      outputType = "json";
+    }
+    const attributes = formatSpanAttributes({
+      // Standard GenAI attributes (v1.38.0)
+      [SEMCONV.GEN_AI_PROVIDER_NAME]: provider,
+      [SEMCONV.GEN_AI_OPERATION_NAME]: OPERATIONS.CHAT,
+      // Most common operation
+      [SEMCONV.GEN_AI_REQUEST_MODEL]: llmRequest.model || "",
+      // Response metadata (Recommended)
+      ...responseId && {
+        [SEMCONV.GEN_AI_RESPONSE_ID]: String(responseId)
+      },
+      // Response model same as request model in most cases
+      [SEMCONV.GEN_AI_RESPONSE_MODEL]: llmRequest.model || "",
+      // Model parameters
+      [SEMCONV.GEN_AI_REQUEST_MAX_TOKENS]: llmRequest.config?.maxOutputTokens || 0,
+      [SEMCONV.GEN_AI_REQUEST_TEMPERATURE]: llmRequest.config?.temperature || 0,
+      [SEMCONV.GEN_AI_REQUEST_TOP_P]: llmRequest.config?.topP || 0,
+      // Additional model parameters (if present)
+      ...llmRequest.config?.topK !== void 0 && {
+        [SEMCONV.GEN_AI_REQUEST_TOP_K]: llmRequest.config.topK
+      },
+      ...llmRequest.config?.frequencyPenalty !== void 0 && {
+        [SEMCONV.GEN_AI_REQUEST_FREQUENCY_PENALTY]: llmRequest.config.frequencyPenalty
+      },
+      ...llmRequest.config?.presencePenalty !== void 0 && {
+        [SEMCONV.GEN_AI_REQUEST_PRESENCE_PENALTY]: llmRequest.config.presencePenalty
+      },
+      ...llmRequest.config?.stopSequences !== void 0 && {
+        [SEMCONV.GEN_AI_REQUEST_STOP_SEQUENCES]: llmRequest.config.stopSequences
+      },
+      ...llmRequest.config?.candidateCount !== void 0 && llmRequest.config.candidateCount !== 1 && {
+        [SEMCONV.GEN_AI_REQUEST_CHOICE_COUNT]: llmRequest.config.candidateCount
+      },
+      // Output type
+      [SEMCONV.GEN_AI_OUTPUT_TYPE]: outputType,
+      // Response metadata
+      ...finishReason && {
+        [SEMCONV.GEN_AI_RESPONSE_FINISH_REASONS]: [finishReason]
+      },
+      // Token usage (input and output only; total computed client-side)
+      ...llmResponse.usageMetadata && {
+        [SEMCONV.GEN_AI_USAGE_INPUT_TOKENS]: llmResponse.usageMetadata.promptTokenCount || 0,
+        [SEMCONV.GEN_AI_USAGE_OUTPUT_TOKENS]: llmResponse.usageMetadata.candidatesTokenCount || 0
+      },
+      // ADK-specific attributes
+      [ADK_ATTRS.LLM_MODEL]: llmRequest.model || "",
+      [ADK_ATTRS.SESSION_ID]: invocationContext.session.id,
+      [ADK_ATTRS.USER_ID]: invocationContext.userId || "",
+      [ADK_ATTRS.INVOCATION_ID]: invocationContext.invocationId,
+      [ADK_ATTRS.EVENT_ID]: eventId,
+      [ADK_ATTRS.ENVIRONMENT]: getEnvironment() || "",
+      // Content attributes (only if capture is enabled) - ADK namespace for backward compat
+      [ADK_ATTRS.LLM_REQUEST]: captureContent ? safeJsonStringify(llmRequestData) : "{}",
+      [ADK_ATTRS.LLM_RESPONSE]: captureContent ? safeJsonStringify(llmResponseData) : "{}"
+    });
+    span.setAttributes(attributes);
+    if (captureContent) {
+      if (llmRequest.config?.systemInstruction) {
+        span.setAttribute(
+          SEMCONV.GEN_AI_SYSTEM_INSTRUCTIONS,
+          safeJsonStringify(llmRequest.config.systemInstruction)
+        );
+      }
+      span.setAttribute(
+        SEMCONV.GEN_AI_INPUT_MESSAGES,
+        safeJsonStringify(llmRequestData.contents || [])
+      );
+      span.setAttribute(
+        SEMCONV.GEN_AI_OUTPUT_MESSAGES,
+        safeJsonStringify(llmResponse.content || llmResponse.text || "")
+      );
+      if (llmRequest.config?.tools) {
+        span.setAttribute(
+          SEMCONV.GEN_AI_TOOL_DEFINITIONS,
+          safeJsonStringify(llmRequest.config.tools)
+        );
+      }
+      span.addEvent(SEMCONV.GEN_AI_CONTENT_PROMPT, {
+        "gen_ai.prompt": safeJsonStringify(llmRequestData.contents || [])
+      });
+      span.addEvent(SEMCONV.GEN_AI_CONTENT_COMPLETION, {
+        "gen_ai.completion": safeJsonStringify(
+          llmResponse.content || llmResponse.text || ""
+        )
+      });
+    }
+  }
+  /**
+   * Wrap an async generator with tracing
+   * Automatically handles span lifecycle, context propagation, and exceptions
+   */
+  async *traceAsyncGenerator(spanName, generator, attributes) {
+    const tracer2 = this.getTracer();
+    const span = tracer2.startSpan(spanName);
+    const spanContext = trace.setSpan(context.active(), span);
+    if (attributes) {
+      span.setAttributes(formatSpanAttributes(attributes));
+    }
+    try {
+      while (true) {
+        const result = await context.with(spanContext, () => generator.next());
+        if (result.done) {
+          span.setStatus({ code: SPAN_STATUS.OK });
+          break;
+        }
+        yield result.value;
+      }
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({
+        code: SPAN_STATUS.ERROR,
+        message: error.message
+      });
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  /**
+   * Create a new span and execute a function within it
+   */
+  async withSpan(spanName, fn, attributes) {
+    const tracer2 = this.getTracer();
+    return tracer2.startActiveSpan(spanName, async (span) => {
+      try {
+        if (attributes) {
+          span.setAttributes(formatSpanAttributes(attributes));
+        }
+        const result = await fn(span);
+        span.setStatus({ code: SPAN_STATUS.OK });
+        return result;
+      } catch (error) {
+        span.recordException(error);
+        span.setStatus({
+          code: SPAN_STATUS.ERROR,
+          message: error.message
+        });
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  }
+  /**
+   * Set attributes on the currently active span
+   */
+  setActiveSpanAttributes(attributes) {
+    const span = this.getActiveSpan();
+    if (span) {
+      span.setAttributes(formatSpanAttributes(attributes));
+    }
+  }
+  /**
+   * Record an exception on the currently active span
+   */
+  recordException(error, attributes) {
+    const span = this.getActiveSpan();
+    if (span) {
+      span.recordException(error);
+      if (attributes) {
+        span.setAttributes(formatSpanAttributes(attributes));
+      }
+    }
+  }
+  /**
+   * Add an event to the currently active span
+   */
+  addEvent(name, attributes) {
+    const span = this.getActiveSpan();
+    if (span && attributes) {
+      span.addEvent(name, formatSpanAttributes(attributes));
+    }
+  }
+  /**
+   * Trace a callback execution
+   * Wraps callback execution in a span with appropriate attributes
+   */
+  traceCallback(callbackType, callbackName, callbackIndex, invocationContext) {
+    const span = this.getActiveSpan();
+    if (!span) return;
+    const attributes = formatSpanAttributes({
+      [SEMCONV.GEN_AI_PROVIDER_NAME]: "iqai-adk",
+      [SEMCONV.GEN_AI_OPERATION_NAME]: OPERATIONS.EXECUTE_CALLBACK,
+      [ADK_ATTRS.CALLBACK_TYPE]: callbackType,
+      [ADK_ATTRS.CALLBACK_NAME]: callbackName || "<anonymous>",
+      [ADK_ATTRS.CALLBACK_INDEX]: callbackIndex,
+      [ADK_ATTRS.ENVIRONMENT]: getEnvironment() || "",
+      ...this.buildInvocationContextAttrs(invocationContext)
+    });
+    span.setAttributes(attributes);
+  }
+  /**
+   * Trace an agent transfer
+   * Records transfer events and attributes for multi-agent workflows
+   */
+  traceAgentTransfer(sourceAgent, targetAgent, transferChain, transferDepth, reason, invocationContext) {
+    const span = this.getActiveSpan();
+    if (!span) return;
+    const attributes = formatSpanAttributes({
+      [SEMCONV.GEN_AI_PROVIDER_NAME]: "iqai-adk",
+      [SEMCONV.GEN_AI_OPERATION_NAME]: OPERATIONS.TRANSFER_AGENT,
+      [ADK_ATTRS.TRANSFER_SOURCE_AGENT]: sourceAgent,
+      [ADK_ATTRS.TRANSFER_TARGET_AGENT]: targetAgent,
+      [ADK_ATTRS.TRANSFER_CHAIN]: JSON.stringify(transferChain),
+      [ADK_ATTRS.TRANSFER_DEPTH]: transferDepth,
+      [ADK_ATTRS.TRANSFER_ROOT_AGENT]: transferChain[0] || sourceAgent,
+      [ADK_ATTRS.ENVIRONMENT]: getEnvironment() || "",
+      ...reason && { [ADK_ATTRS.TRANSFER_REASON]: reason },
+      ...this.buildInvocationContextAttrs(invocationContext)
+    });
+    span.setAttributes(attributes);
+    span.addEvent("agent_transfer_initiated", {
+      target_agent: targetAgent,
+      transfer_depth: transferDepth
+    });
+  }
+  /**
+   * Record enhanced tool execution attributes
+   * Extends the basic tool tracing with execution order and parallel tracking
+   */
+  traceEnhancedTool(executionOrder, parallelGroup, retryCount, isCallbackOverride) {
+    this.setActiveSpanAttributes({
+      ...executionOrder !== void 0 && {
+        [ADK_ATTRS.TOOL_EXECUTION_ORDER]: executionOrder
+      },
+      ...parallelGroup !== void 0 && {
+        [ADK_ATTRS.TOOL_PARALLEL_GROUP]: parallelGroup
+      },
+      ...retryCount !== void 0 && {
+        [ADK_ATTRS.TOOL_RETRY_COUNT]: retryCount
+      },
+      ...isCallbackOverride !== void 0 && {
+        [ADK_ATTRS.TOOL_IS_CALLBACK_OVERRIDE]: isCallbackOverride
+      }
+    });
+  }
+  /**
+   * Record enhanced LLM attributes
+   * Extends basic LLM tracing with streaming metrics
+   */
+  traceEnhancedLlm(streaming, timeToFirstTokenMs, chunkCount, cachedTokens, contextWindowUsedPct) {
+    this.setActiveSpanAttributes({
+      ...streaming !== void 0 && {
+        [ADK_ATTRS.LLM_STREAMING]: streaming
+      },
+      ...timeToFirstTokenMs !== void 0 && {
+        [ADK_ATTRS.LLM_TIME_TO_FIRST_TOKEN]: timeToFirstTokenMs
+      },
+      ...chunkCount !== void 0 && {
+        [ADK_ATTRS.LLM_CHUNK_COUNT]: chunkCount
+      },
+      ...cachedTokens !== void 0 && {
+        [ADK_ATTRS.LLM_CACHED_TOKENS]: cachedTokens
+      },
+      ...contextWindowUsedPct !== void 0 && {
+        [ADK_ATTRS.LLM_CONTEXT_WINDOW_USED_PCT]: contextWindowUsedPct
+      }
+    });
+  }
+  /**
+   * Record standardized error information
+   * Provides consistent error handling across all operations
+   */
+  traceError(error, category, recoverable = false, retryRecommended = false) {
+    const span = this.getActiveSpan();
+    if (!span) return;
+    span.recordException(error);
+    span.setStatus({ code: SPAN_STATUS.ERROR, message: error.message });
+    span.setAttributes(
+      formatSpanAttributes({
+        [SEMCONV.ERROR_TYPE]: error.constructor.name,
+        "error.message": error.message,
+        "error.stack": error.stack?.substring(0, 1e3) || "",
+        [ADK_ATTRS.ERROR_CATEGORY]: category,
+        [ADK_ATTRS.ERROR_RECOVERABLE]: recoverable,
+        [ADK_ATTRS.ERROR_RETRY_RECOMMENDED]: retryRecommended
+      })
+    );
+  }
+  /**
+   * Trace memory operations
+   * Records memory search, insert, and delete operations
+   */
+  traceMemoryOperation(operation, sessionId, query, resultsCount, invocationContext) {
+    const span = this.getActiveSpan();
+    if (!span) return;
+    span.setAttributes(
+      formatSpanAttributes({
+        [SEMCONV.GEN_AI_PROVIDER_NAME]: "iqai-adk",
+        [SEMCONV.GEN_AI_OPERATION_NAME]: operation === "search" ? OPERATIONS.SEARCH_MEMORY : OPERATIONS.INSERT_MEMORY,
+        [ADK_ATTRS.SESSION_ID]: sessionId,
+        [ADK_ATTRS.ENVIRONMENT]: getEnvironment() || "",
+        ...query && { [ADK_ATTRS.MEMORY_QUERY]: query },
+        ...resultsCount !== void 0 && {
+          [ADK_ATTRS.MEMORY_RESULTS_COUNT]: resultsCount
+        },
+        ...invocationContext && {
+          [ADK_ATTRS.USER_ID]: invocationContext.userId || "",
+          [ADK_ATTRS.INVOCATION_ID]: invocationContext.invocationId
+        }
+      })
+    );
+  }
+  /**
+   * Trace plugin hook execution
+   * Records plugin lifecycle hooks
+   */
+  tracePluginHook(pluginName, hook, agentName, invocationContext) {
+    const span = this.getActiveSpan();
+    if (!span) return;
+    span.setAttributes(
+      formatSpanAttributes({
+        [SEMCONV.GEN_AI_PROVIDER_NAME]: "iqai-adk",
+        [SEMCONV.GEN_AI_OPERATION_NAME]: OPERATIONS.EXECUTE_PLUGIN,
+        [ADK_ATTRS.PLUGIN_NAME]: pluginName,
+        [ADK_ATTRS.PLUGIN_HOOK]: hook,
+        [ADK_ATTRS.ENVIRONMENT]: getEnvironment() || "",
+        ...agentName && { [ADK_ATTRS.AGENT_NAME]: agentName },
+        ...this.buildInvocationContextAttrs(invocationContext)
+      })
+    );
+  }
+};
+var tracingService = new TracingService();
+
+// src/telemetry/index.ts
+var TelemetryService = class {
+  /**
+   * Initialize telemetry system
+   */
+  async initialize(config) {
+    await setupService.initialize(config);
+    const appVersion = config.appVersion || "0.0.0";
+    tracingService.initialize("iqai-adk", appVersion);
+    if (config.enableMetrics !== false) {
+      metricsService.initialize("iqai-adk", appVersion);
+    }
+  }
+  /**
+   * Check if telemetry is initialized
+   */
+  get initialized() {
+    return setupService.initialized;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return setupService.getConfig();
+  }
+  /**
+   * Get tracer instance
+   */
+  getTracer() {
+    return tracingService.getTracer();
+  }
+  /**
+   * Get currently active span
+   */
+  getActiveSpan() {
+    return tracingService.getActiveSpan();
+  }
+  /**
+   * Check if content capture is enabled
+   */
+  shouldCaptureContent() {
+    return shouldCaptureContent();
+  }
+  // --- Tracing Methods ---
+  /**
+   * Trace an agent invocation
+   */
+  traceAgentInvocation(agent, invocationContext, input, output) {
+    tracingService.traceAgentInvocation(
+      agent,
+      invocationContext,
+      input,
+      output
+    );
+  }
+  /**
+   * Trace a tool call
+   */
+  traceToolCall(tool, args, functionResponseEvent, llmRequest, invocationContext) {
+    tracingService.traceToolCall(
+      tool,
+      args,
+      functionResponseEvent,
+      llmRequest,
+      invocationContext
+    );
+  }
+  /**
+   * Trace an LLM call
+   */
+  traceLlmCall(invocationContext, eventId, llmRequest, llmResponse) {
+    tracingService.traceLlmCall(
+      invocationContext,
+      eventId,
+      llmRequest,
+      llmResponse
+    );
+  }
+  /**
+   * Wrap an async generator with tracing
+   */
+  traceAsyncGenerator(spanName, generator, attributes) {
+    return tracingService.traceAsyncGenerator(spanName, generator, attributes);
+  }
+  /**
+   * Execute a function within a traced span
+   */
+  async withSpan(spanName, fn, attributes) {
+    return tracingService.withSpan(spanName, fn, attributes);
+  }
+  /**
+   * Set attributes on the active span
+   */
+  setActiveSpanAttributes(attributes) {
+    tracingService.setActiveSpanAttributes(attributes);
+  }
+  /**
+   * Record an exception on the active span
+   */
+  recordException(error, attributes) {
+    tracingService.recordException(error, attributes);
+  }
+  /**
+   * Add an event to the active span
+   */
+  addEvent(name, attributes) {
+    tracingService.addEvent(name, attributes);
+  }
+  /**
+   * Trace a callback execution
+   */
+  traceCallback(callbackType, callbackName, callbackIndex, invocationContext) {
+    tracingService.traceCallback(
+      callbackType,
+      callbackName,
+      callbackIndex,
+      invocationContext
+    );
+  }
+  /**
+   * Trace an agent transfer
+   */
+  traceAgentTransfer(sourceAgent, targetAgent, transferChain, transferDepth, reason, invocationContext) {
+    tracingService.traceAgentTransfer(
+      sourceAgent,
+      targetAgent,
+      transferChain,
+      transferDepth,
+      reason,
+      invocationContext
+    );
+  }
+  /**
+   * Record enhanced tool execution attributes
+   */
+  traceEnhancedTool(executionOrder, parallelGroup, retryCount, isCallbackOverride) {
+    tracingService.traceEnhancedTool(
+      executionOrder,
+      parallelGroup,
+      retryCount,
+      isCallbackOverride
+    );
+  }
+  /**
+   * Record enhanced LLM attributes
+   */
+  traceEnhancedLlm(streaming, timeToFirstTokenMs, chunkCount, cachedTokens, contextWindowUsedPct) {
+    tracingService.traceEnhancedLlm(
+      streaming,
+      timeToFirstTokenMs,
+      chunkCount,
+      cachedTokens,
+      contextWindowUsedPct
+    );
+  }
+  /**
+   * Record standardized error information
+   */
+  traceError(error, category, recoverable = false, retryRecommended = false) {
+    tracingService.traceError(error, category, recoverable, retryRecommended);
+  }
+  /**
+   * Trace memory operations
+   */
+  traceMemoryOperation(operation, sessionId, query, resultsCount, invocationContext) {
+    tracingService.traceMemoryOperation(
+      operation,
+      sessionId,
+      query,
+      resultsCount,
+      invocationContext
+    );
+  }
+  /**
+   * Trace plugin hook execution
+   */
+  tracePluginHook(pluginName, hook, agentName, invocationContext) {
+    tracingService.tracePluginHook(
+      pluginName,
+      hook,
+      agentName,
+      invocationContext
+    );
   }
+  // --- Metrics Methods ---
   /**
-   * Initialize telemetry with the provided configuration
+   * Record an agent invocation
    */
-  initialize(config) {
-    if (this.isInitialized) {
-      diag.warn("Telemetry is already initialized. Skipping.");
-      return;
-    }
-    this.config = config;
-    diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
-    const resource = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: config.appName,
-      [ATTR_SERVICE_VERSION]: config.appVersion
-    });
-    const traceExporter = new OTLPTraceExporter({
-      url: config.otlpEndpoint,
-      headers: config.otlpHeaders
-    });
-    this.sdk = new NodeSDK({
-      resource,
-      traceExporter,
-      instrumentations: [
-        getNodeAutoInstrumentations({
-          // Follow Python ADK approach: let all HTTP instrumentation through.
-          // This provides transparency and aligns with standard OpenTelemetry behavior.
-          // High-level LLM tracing is provided through dedicated ADK spans.
-          "@opentelemetry/instrumentation-http": {
-            ignoreIncomingRequestHook: (req) => {
-              return true;
-            }
-          }
-        })
-      ]
-    });
-    try {
-      this.sdk.start();
-      this.isInitialized = true;
-      this.tracer = trace.getTracer("iqai-adk", config.appVersion || "0.1.0");
-      diag.debug("OpenTelemetry SDK started successfully.");
-    } catch (error) {
-      diag.error("Error starting OpenTelemetry SDK:", error);
-      throw error;
-    }
+  recordAgentInvocation(dimensions) {
+    metricsService.recordAgentInvocation(dimensions);
   }
   /**
-   * Get the tracer instance
+   * Record agent duration
    */
-  getTracer() {
-    return this.tracer;
+  recordAgentDuration(durationMs, dimensions) {
+    metricsService.recordAgentDuration(durationMs, dimensions);
   }
   /**
-   * Check if telemetry is initialized
+   * Record a tool execution
    */
-  get initialized() {
-    return this.isInitialized;
+  recordToolExecution(dimensions) {
+    metricsService.recordToolExecution(dimensions);
   }
   /**
-   * Get the current configuration
+   * Record tool duration
    */
-  getConfig() {
-    return this.config;
+  recordToolDuration(durationMs, dimensions) {
+    metricsService.recordToolDuration(durationMs, dimensions);
   }
   /**
-   * Shutdown telemetry with optional timeout
+   * Record an LLM call
    */
-  async shutdown(timeoutMs = 5e3) {
-    if (!this.sdk || !this.isInitialized) {
-      diag.warn("Telemetry is not initialized or already shut down.");
-      return;
-    }
-    try {
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(
-          () => reject(
-            new Error(`Telemetry shutdown timeout after ${timeoutMs}ms`)
-          ),
-          timeoutMs
-        );
-      });
-      await Promise.race([this.sdk.shutdown(), timeoutPromise]);
-      this.isInitialized = false;
-      diag.debug("Telemetry terminated successfully.");
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("timeout")) {
-        diag.warn("Telemetry shutdown timed out, some traces may be lost");
-      } else {
-        diag.error("Error terminating telemetry:", error);
-      }
-      throw error;
-    } finally {
-      this.sdk = null;
-    }
+  recordLlmCall(dimensions) {
+    metricsService.recordLlmCall(dimensions);
   }
   /**
-   * Traces a tool call by adding detailed attributes to the current span.
+   * Record LLM duration
    */
-  traceToolCall(tool, args, functionResponseEvent, llmRequest, invocationContext) {
-    const span = trace.getActiveSpan();
-    if (!span) return;
-    let toolCallId = "<not specified>";
-    let toolResponse = "<not specified>";
-    if (functionResponseEvent.content?.parts && functionResponseEvent.content.parts.length > 0) {
-      const functionResponse = functionResponseEvent.content.parts[0].functionResponse;
-      if (functionResponse) {
-        toolCallId = functionResponse.id || "<not specified>";
-        toolResponse = JSON.stringify(functionResponse.response) || "<not specified>";
-      }
-    }
-    span.setAttributes({
-      "gen_ai.system": "iqai-adk",
-      "gen_ai.operation.name": "execute_tool",
-      "gen_ai.tool.name": tool.name,
-      "gen_ai.tool.description": tool.description,
-      "gen_ai.tool.call.id": toolCallId,
-      // Session and user tracking
-      ...invocationContext && {
-        "session.id": invocationContext.session.id,
-        "user.id": invocationContext.userId
-      },
-      // Environment
-      ...process.env.NODE_ENV && {
-        "deployment.environment.name": process.env.NODE_ENV
-      },
-      // ADK-specific attributes (matching Python namespace pattern)
-      "adk.tool_call_args": this._safeJsonStringify(args),
-      "adk.event_id": functionResponseEvent.invocationId,
-      "adk.tool_response": this._safeJsonStringify(toolResponse),
-      "adk.llm_request": llmRequest ? this._safeJsonStringify(this._buildLlmRequestForTrace(llmRequest)) : "{}",
-      "adk.llm_response": "{}"
-    });
+  recordLlmDuration(durationMs, dimensions) {
+    metricsService.recordLlmDuration(durationMs, dimensions);
   }
   /**
-   * Traces a call to the LLM by adding detailed attributes to the current span.
+   * Record LLM token usage
    */
-  traceLlmCall(invocationContext, eventId, llmRequest, llmResponse) {
-    const span = trace.getActiveSpan();
-    if (!span) return;
-    const requestData = this._buildLlmRequestForTrace(llmRequest);
-    span.setAttributes({
-      // Standard OpenTelemetry attributes (following Python pattern)
-      "gen_ai.system": "iqai-adk",
-      "gen_ai.request.model": llmRequest.model,
-      // Session and user tracking (maps to Langfuse sessionId, userId)
-      "session.id": invocationContext.session.id,
-      "user.id": invocationContext.userId,
-      // Environment (maps to Langfuse environment)
-      ...process.env.NODE_ENV && {
-        "deployment.environment.name": process.env.NODE_ENV
-      },
-      // Model parameters (maps to Langfuse modelParameters)
-      "gen_ai.request.max_tokens": llmRequest.config.maxOutputTokens || 0,
-      "gen_ai.request.temperature": llmRequest.config.temperature || 0,
-      "gen_ai.request.top_p": llmRequest.config.topP || 0,
-      "adk.system_name": "iqai-adk",
-      "adk.request_model": llmRequest.model,
-      // ADK-specific attributes (matching Python namespace pattern)
-      "adk.invocation_id": invocationContext.invocationId,
-      "adk.session_id": invocationContext.session.id,
-      "adk.event_id": eventId,
-      "adk.llm_request": this._safeJsonStringify(requestData),
-      "adk.llm_response": this._safeJsonStringify(llmResponse)
-    });
-    if (llmResponse.usageMetadata) {
-      span.setAttributes({
-        "gen_ai.usage.input_tokens": llmResponse.usageMetadata.promptTokenCount || 0,
-        "gen_ai.usage.output_tokens": llmResponse.usageMetadata.candidatesTokenCount || 0
-      });
-    }
-    span.addEvent("gen_ai.content.prompt", {
-      "gen_ai.prompt": this._safeJsonStringify(requestData.messages)
-    });
-    span.addEvent("gen_ai.content.completion", {
-      "gen_ai.completion": this._safeJsonStringify(llmResponse.content || "")
-    });
+  recordLlmTokens(inputTokens, outputTokens, dimensions) {
+    metricsService.recordLlmTokens(inputTokens, outputTokens, dimensions);
   }
   /**
-   * Wraps an async generator with tracing
+   * Record an error
    */
-  async *traceAsyncGenerator(spanName, generator) {
-    const span = this.tracer.startSpan(spanName);
-    const spanContext = trace.setSpan(context.active(), span);
-    try {
-      while (true) {
-        const result = await context.with(spanContext, () => generator.next());
-        if (result.done) {
-          break;
-        }
-        yield result.value;
-      }
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({ code: 2, message: error.message });
-      throw error;
-    } finally {
-      span.end();
-    }
-  }
-  // --- Private Helper Methods ---
-  _safeJsonStringify(obj) {
-    try {
-      return JSON.stringify(obj);
-    } catch (e) {
-      return "<not serializable>";
-    }
+  recordError(errorType, context4) {
+    metricsService.recordError(errorType, context4);
   }
+  // --- Lifecycle Methods ---
   /**
-   * Builds a dictionary representation of the LLM request for tracing.
-   *
-   * This function prepares a dictionary representation of the LlmRequest
-   * object, suitable for inclusion in a trace. It excludes fields that cannot
-   * be serialized (e.g., function pointers) and avoids sending bytes data.
-   */
-  _buildLlmRequestForTrace(llmRequest) {
-    const result = {
-      model: llmRequest.model,
-      config: this._excludeNonSerializableFromConfig(llmRequest.config),
-      contents: []
-    };
-    for (const content of llmRequest.contents || []) {
-      const parts = content.parts?.filter((part) => !part.inlineData) || [];
-      result.contents.push({
-        role: content.role,
-        parts
-      });
-    }
-    return result;
+   * Flush all pending telemetry data
+   */
+  async flush(timeoutMs = 5e3) {
+    await setupService.flush(timeoutMs);
   }
   /**
-   * Excludes non-serializable fields from config, similar to Python's exclude logic
+   * Shutdown telemetry system
    */
-  _excludeNonSerializableFromConfig(config) {
-    const result = {};
-    for (const [key, value] of Object.entries(config)) {
-      if (key === "response_schema") {
-        continue;
-      }
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (key === "functions" && Array.isArray(value)) {
-        result[key] = value.map((func) => ({
-          name: func.name,
-          description: func.description,
-          parameters: func.parameters
-          // Exclude actual function pointers
-        }));
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
+  async shutdown(timeoutMs) {
+    await setupService.shutdown(timeoutMs);
   }
 };
 var telemetryService = new TelemetryService();
 var tracer = telemetryService.getTracer();
 var initializeTelemetry = (config) => telemetryService.initialize(config);
 var shutdownTelemetry = (timeoutMs) => telemetryService.shutdown(timeoutMs);
+var traceAgentInvocation = (agent, invocationContext, input, output) => telemetryService.traceAgentInvocation(
+  agent,
+  invocationContext,
+  input,
+  output
+);
 var traceToolCall = (tool, args, functionResponseEvent, llmRequest, invocationContext) => telemetryService.traceToolCall(
   tool,
   args,
@@ -1554,6 +2949,9 @@ var traceLlmCall = (invocationContext, eventId, llmRequest, llmResponse) => tele
   llmRequest,
   llmResponse
 );
+var recordAgentInvocation = (dimensions) => telemetryService.recordAgentInvocation(dimensions);
+var recordToolExecution = (dimensions) => telemetryService.recordToolExecution(dimensions);
+var recordLlmCall = (dimensions) => telemetryService.recordLlmCall(dimensions);
 
 // src/models/base-llm.ts
 var BaseLlm = class {
@@ -1589,66 +2987,119 @@ var BaseLlm = class {
    */
   async *generateContentAsync(llmRequest, stream) {
     this.maybeAppendUserContent(llmRequest);
-    yield* tracer.startActiveSpan(
-      `llm_generate [${this.model}]`,
-      async function* (span) {
-        try {
-          span.setAttributes({
-            "gen_ai.system.name": "iqai-adk",
-            "gen_ai.operation.name": "generate",
-            "gen_ai.request.model": this.model,
-            "gen_ai.request.max_tokens": llmRequest.config?.maxOutputTokens || 0,
-            "gen_ai.request.temperature": llmRequest.config?.temperature || 0,
-            "gen_ai.request.top_p": llmRequest.config?.topP || 0,
-            "adk.llm_request": JSON.stringify({
-              model: this.model,
-              contents: llmRequest.contents?.map((content) => ({
-                role: content.role,
-                parts: content.parts?.map((part) => ({
-                  text: typeof part.text === "string" ? part.text.substring(0, 200) + (part.text.length > 200 ? "..." : "") : "[non_text_content]"
-                }))
-              })),
-              config: llmRequest.config
-            }),
-            "adk.streaming": stream || false
-          });
-          let responseCount = 0;
-          let totalTokens = 0;
-          for await (const response of this.generateContentAsyncImpl(
-            llmRequest,
-            stream
-          )) {
-            responseCount++;
-            if (response.usage) {
-              totalTokens += response.usage.total_tokens || 0;
-              span.setAttributes({
-                "gen_ai.response.finish_reasons": [
-                  response.finish_reason || "unknown"
-                ],
-                "gen_ai.usage.input_tokens": response.usage.prompt_tokens || 0,
-                "gen_ai.usage.output_tokens": response.usage.completion_tokens || 0,
-                "gen_ai.usage.total_tokens": response.usage.total_tokens || 0
-              });
-            }
-            yield response;
+    const span = trace2.getActiveSpan();
+    const captureContent = shouldCaptureContent();
+    if (span && captureContent) {
+      span.setAttributes({
+        "gen_ai.system": "iqai-adk",
+        "gen_ai.operation.name": stream ? "stream" : "generate",
+        "gen_ai.request.model": this.model,
+        "gen_ai.request.max_tokens": llmRequest.config?.maxOutputTokens || 0,
+        "gen_ai.request.temperature": llmRequest.config?.temperature || 0,
+        "gen_ai.request.top_p": llmRequest.config?.topP || 0,
+        "adk.llm.streaming": stream || false
+      });
+      if (llmRequest.contents) {
+        span.addEvent("gen_ai.content.prompt", {
+          "gen_ai.prompt": JSON.stringify(llmRequest.contents)
+        });
+      }
+    }
+    let responseCount = 0;
+    let totalTokens = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let firstTokenTime;
+    const startTime = Date.now();
+    let chunkCount = 0;
+    let accumulatedContent = null;
+    try {
+      for await (const response of this.generateContentAsyncImpl(
+        llmRequest,
+        stream
+      )) {
+        responseCount++;
+        if (stream && !firstTokenTime) {
+          firstTokenTime = Date.now();
+          const timeToFirstToken = firstTokenTime - startTime;
+          telemetryService.traceEnhancedLlm(
+            true,
+            // streaming
+            timeToFirstToken
+          );
+          if (span) {
+            span.addEvent("gen_ai.stream.first_token", {
+              time_to_first_token_ms: timeToFirstToken
+            });
+          }
+        }
+        if (stream) {
+          chunkCount++;
+          if (span) {
+            span.addEvent("gen_ai.stream.chunk", {
+              chunk_index: chunkCount,
+              timestamp: Date.now()
+            });
+          }
+        }
+        if (response.content) {
+          accumulatedContent = response.content;
+        } else if (response.text) {
+          if (!accumulatedContent) {
+            accumulatedContent = { role: "model", parts: [{ text: "" }] };
+          }
+          if (accumulatedContent.parts?.[0]) {
+            accumulatedContent.parts[0].text = (accumulatedContent.parts[0].text || "") + response.text;
           }
+        }
+        if (response.usageMetadata && span) {
+          inputTokens = response.usageMetadata.promptTokenCount || inputTokens;
+          outputTokens = response.usageMetadata.candidatesTokenCount || outputTokens;
+          totalTokens = response.usageMetadata.totalTokenCount || totalTokens;
           span.setAttributes({
-            "adk.response_count": responseCount,
-            "adk.total_tokens": totalTokens
+            "gen_ai.usage.input_tokens": inputTokens,
+            "gen_ai.usage.output_tokens": outputTokens,
+            "gen_ai.usage.total_tokens": totalTokens
           });
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({ code: 2, message: error.message });
-          this.logger.error("\u274C ADK LLM Error:", {
-            model: this.model,
-            error: error.message
+        }
+        if (response.finishReason && span) {
+          span.setAttribute("gen_ai.response.finish_reasons", [
+            response.finishReason
+          ]);
+        }
+        yield response;
+      }
+      if (span) {
+        span.setAttributes({
+          "adk.response_count": responseCount
+        });
+        if (captureContent && accumulatedContent) {
+          span.addEvent("gen_ai.content.completion", {
+            "gen_ai.completion": JSON.stringify(accumulatedContent)
           });
-          throw error;
-        } finally {
-          span.end();
         }
-      }.bind(this)
-    );
+      }
+      if (stream && chunkCount > 0) {
+        telemetryService.traceEnhancedLlm(
+          true,
+          firstTokenTime ? firstTokenTime - startTime : void 0,
+          chunkCount
+        );
+      }
+    } catch (error) {
+      telemetryService.traceError(
+        error,
+        "model_error",
+        false,
+        true
+        // retry may be recommended for transient model errors
+      );
+      this.logger.error("\u274C ADK LLM Error:", {
+        model: this.model,
+        error: error.message
+      });
+      throw error;
+    }
   }
   /**
    * Appends a user content, so that model can continue to output.
@@ -6413,7 +7864,7 @@ var ToolContext = class extends CallbackContext {
 };
 
 // src/flows/llm-flows/functions.ts
-import { context as context2, trace as trace2 } from "@opentelemetry/api";
+import { context as context2, trace as trace3 } from "@opentelemetry/api";
 var AF_FUNCTION_CALL_ID_PREFIX = "adk-";
 var REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
 function generateClientFunctionCallId() {
@@ -6492,6 +7943,7 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
     return null;
   }
   const functionResponseEvents = [];
+  let executionOrder = 0;
   for (const functionCall of functionCalls) {
     if (filters && functionCall.id && !filters.has(functionCall.id)) {
       continue;
@@ -6503,8 +7955,11 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
     );
     const functionArgs = functionCall.args || {};
     const tracer2 = telemetryService.getTracer();
-    const span = tracer2.startSpan(`execute_tool ${tool.name}`);
-    const spanContext = trace2.setSpan(context2.active(), span);
+    const span = tracer2.startSpan(`execute_tool [${tool.name}]`);
+    const spanContext = trace3.setSpan(context2.active(), span);
+    const toolStartTime = Date.now();
+    let toolStatus = "success";
+    let wasOverridden = false;
     try {
       const functionResponse = await context2.with(spanContext, async () => {
         const argsForTool = { ...functionArgs };
@@ -6512,6 +7967,7 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
           for (const cb of agent.canonicalBeforeToolCallbacks) {
             const maybeOverride = await cb(tool, argsForTool, toolContext);
             if (maybeOverride !== null && maybeOverride !== void 0) {
+              wasOverridden = true;
               const overriddenEvent = buildResponseEvent(
                 tool,
                 maybeOverride,
@@ -6521,7 +7977,19 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
               telemetryService.traceToolCall(
                 tool,
                 argsForTool,
-                overriddenEvent
+                overriddenEvent,
+                void 0,
+                // llmRequest
+                invocationContext
+              );
+              telemetryService.traceEnhancedTool(
+                executionOrder,
+                void 0,
+                // parallelGroup not used in sequential execution
+                0,
+                // no retry
+                true
+                // callback override
               );
               return { result: maybeOverride, event: overriddenEvent };
             }
@@ -6554,7 +8022,18 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
         telemetryService.traceToolCall(
           tool,
           argsForTool,
-          functionResponseEvent
+          functionResponseEvent,
+          void 0,
+          // llmRequest
+          invocationContext
+        );
+        telemetryService.traceEnhancedTool(
+          executionOrder,
+          void 0,
+          // parallelGroup not used in sequential execution
+          0,
+          // no retry
+          wasOverridden
         );
         return { result, event: functionResponseEvent };
       });
@@ -6563,11 +8042,41 @@ async function handleFunctionCallsAsync(invocationContext, functionCallEvent, to
       }
       functionResponseEvents.push(functionResponse.event);
       span.setStatus({ code: 1 });
+      telemetryService.recordToolExecution({
+        toolName: tool.name,
+        agentName: agent.name,
+        environment: process.env.NODE_ENV,
+        status: toolStatus
+      });
+      executionOrder++;
     } catch (error) {
+      toolStatus = "error";
+      telemetryService.traceError(
+        error,
+        "tool_error",
+        false,
+        // not recoverable by default
+        false
+        // retry not recommended by default
+      );
       span.recordException(error);
       span.setStatus({ code: 2, message: error.message });
+      telemetryService.recordToolExecution({
+        toolName: tool.name,
+        agentName: agent.name,
+        environment: process.env.NODE_ENV,
+        status: toolStatus
+      });
+      telemetryService.recordError("tool", tool.name);
       throw error;
     } finally {
+      const toolDuration = Date.now() - toolStartTime;
+      telemetryService.recordToolDuration(toolDuration, {
+        toolName: tool.name,
+        agentName: agent.name,
+        environment: process.env.NODE_ENV,
+        status: toolStatus
+      });
       span.end();
     }
   }
@@ -6716,21 +8225,29 @@ var BaseLlmFlow = class {
       author: invocationContext.agent.name,
       branch: invocationContext.branch
     });
-    for await (const llmResponse of this._callLlmAsync(
-      invocationContext,
-      llmRequest,
-      modelResponseEvent
-    )) {
-      for await (const event of this._postprocessAsync(
+    const llm = this.__getLlm(invocationContext);
+    const isStreaming = invocationContext.runConfig.streamingMode === "sse" /* SSE */;
+    const generator = async function* () {
+      for await (const llmResponse of this._callLlmAsync(
         invocationContext,
         llmRequest,
-        llmResponse,
         modelResponseEvent
       )) {
-        modelResponseEvent.id = Event.newId();
-        yield event;
+        for await (const event of this._postprocessAsync(
+          invocationContext,
+          llmRequest,
+          llmResponse,
+          modelResponseEvent
+        )) {
+          modelResponseEvent.id = Event.newId();
+          yield event;
+        }
       }
-    }
+    }.bind(this)();
+    yield* telemetryService.traceAsyncGenerator(
+      isStreaming ? `llm_stream [${llm.model}]` : `llm_generate [${llm.model}]`,
+      generator
+    );
   }
   async *_preprocessAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;
@@ -6976,37 +8493,71 @@ var BaseLlmFlow = class {
       Streaming: isStreaming ? "Yes" : "No"
     });
     let responseCount = 0;
-    for await (const llmResponse of llm.generateContentAsync(
-      llmRequest,
-      isStreaming
-    )) {
-      responseCount++;
-      traceLlmCall(
-        invocationContext,
-        modelResponseEvent.id,
+    const llmStartTime = Date.now();
+    let llmStatus = "success";
+    try {
+      for await (const llmResponse of llm.generateContentAsync(
         llmRequest,
-        llmResponse
-      );
-      const tokenCount = llmResponse.usageMetadata?.totalTokenCount || "unknown";
-      const functionCalls = llmResponse.content?.parts?.filter((part) => part.functionCall) || [];
-      const functionCallsDisplay = LogFormatter.formatFunctionCalls(functionCalls);
-      const responsePreview = LogFormatter.formatResponsePreview(llmResponse);
-      this.logger.debugStructured("\u{1F4E5} LLM Response", {
-        Model: llm.model,
-        "Token Count": tokenCount,
-        "Function Calls": functionCallsDisplay,
-        "Response Preview": responsePreview,
-        "Finish Reason": llmResponse.finishReason || "unknown",
-        "Response #": responseCount,
-        Partial: llmResponse.partial ? "Yes" : "No",
-        Error: llmResponse.errorCode || "none"
+        isStreaming
+      )) {
+        responseCount++;
+        traceLlmCall(
+          invocationContext,
+          modelResponseEvent.id,
+          llmRequest,
+          llmResponse
+        );
+        if (llmResponse.usageMetadata) {
+          telemetryService.recordLlmTokens(
+            llmResponse.usageMetadata.promptTokenCount || 0,
+            llmResponse.usageMetadata.candidatesTokenCount || 0,
+            {
+              model: llm.model,
+              agentName: invocationContext.agent.name,
+              environment: process.env.NODE_ENV,
+              status: llmStatus
+            }
+          );
+        }
+        telemetryService.recordLlmCall({
+          model: llm.model,
+          agentName: invocationContext.agent.name,
+          environment: process.env.NODE_ENV,
+          status: llmStatus
+        });
+        const tokenCount = llmResponse.usageMetadata?.totalTokenCount || "unknown";
+        const functionCalls = llmResponse.content?.parts?.filter((part) => part.functionCall) || [];
+        const functionCallsDisplay = LogFormatter.formatFunctionCalls(functionCalls);
+        const responsePreview = LogFormatter.formatResponsePreview(llmResponse);
+        this.logger.debugStructured("\u{1F4E5} LLM Response", {
+          Model: llm.model,
+          "Token Count": tokenCount,
+          "Function Calls": functionCallsDisplay,
+          "Response Preview": responsePreview,
+          "Finish Reason": llmResponse.finishReason || "unknown",
+          "Response #": responseCount,
+          Partial: llmResponse.partial ? "Yes" : "No",
+          Error: llmResponse.errorCode || "none"
+        });
+        const alteredLlmResponse = await this._handleAfterModelCallback(
+          invocationContext,
+          llmResponse,
+          modelResponseEvent
+        );
+        yield alteredLlmResponse || llmResponse;
+      }
+    } catch (error) {
+      llmStatus = "error";
+      telemetryService.recordError("llm", llm.model);
+      throw error;
+    } finally {
+      const llmDuration = Date.now() - llmStartTime;
+      telemetryService.recordLlmDuration(llmDuration, {
+        model: llm.model,
+        agentName: invocationContext.agent.name,
+        environment: process.env.NODE_ENV,
+        status: llmStatus
       });
-      const alteredLlmResponse = await this._handleAfterModelCallback(
-        invocationContext,
-        llmResponse,
-        modelResponseEvent
-      );
-      yield alteredLlmResponse || llmResponse;
     }
   }
   async _handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
@@ -7303,6 +8854,7 @@ var requestProcessor = new AuthLlmRequestProcessor();
 
 // src/flows/llm-flows/basic.ts
 init_logger();
+import * as z2 from "zod";
 var BasicLlmRequestProcessor = class extends BaseLlmRequestProcessor {
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;
@@ -7321,7 +8873,13 @@ var BasicLlmRequestProcessor = class extends BaseLlmRequestProcessor {
       const hasTools = (await agent.canonicalTools?.(invocationContext))?.length > 0;
       const hasTransfers = !!("subAgents" in agent && agent.subAgents && agent.subAgents.length > 0 && !(agent.disallowTransferToParent && agent.disallowTransferToPeers));
       if (!hasTools && !hasTransfers) {
-        llmRequest.setOutputSchema(agent.outputSchema);
+        try {
+          const jsonSchema2 = z2.toJSONSchema(agent.outputSchema);
+          const { $schema, ...cleanSchema } = jsonSchema2;
+          llmRequest.setOutputSchema(cleanSchema);
+        } catch {
+          llmRequest.setOutputSchema(agent.outputSchema);
+        }
       } else {
         (() => {
           try {
@@ -7329,7 +8887,7 @@ var BasicLlmRequestProcessor = class extends BaseLlmRequestProcessor {
             logger2.debug(
               `Skipping request-level output schema for agent ${agent.name} because tools/transfers are present. Schema will be validated during response processing.`
             );
-          } catch (e) {
+          } catch {
           }
         })();
       }
@@ -8408,7 +9966,7 @@ var IdentityLlmRequestProcessor = class extends BaseLlmRequestProcessor {
 var requestProcessor5 = new IdentityLlmRequestProcessor();
 
 // src/flows/llm-flows/instructions.ts
-import z2 from "zod";
+import z3 from "zod";
 
 // src/utils/instructions-utils.ts
 async function injectSessionState(template, readonlyContext) {
@@ -8596,7 +10154,7 @@ var InstructionsLlmRequestProcessor = class extends BaseLlmRequestProcessor {
     }
     if (agent.outputSchema) {
       try {
-        const raw = z2.toJSONSchema(agent.outputSchema);
+        const raw = z3.toJSONSchema(agent.outputSchema);
         const { $schema, ...json } = raw || {};
         llmRequest.appendInstructions([
           "You must respond with application/json that validates against this JSON Schema (do NOT wrap the output in markdown or code fences):",
@@ -9260,22 +10818,88 @@ var BaseAgent = class {
    */
   async *runAsyncInternal(parentContext) {
     const ctx = this.createInvocationContext(parentContext);
-    const beforeEvent = await this.handleBeforeAgentCallback(ctx);
-    if (beforeEvent) {
-      yield beforeEvent;
-    }
-    if (ctx.endInvocation) {
-      return;
-    }
-    for await (const event of this.runAsyncImpl(ctx)) {
-      yield event;
-    }
-    if (ctx.endInvocation) {
-      return;
-    }
-    const afterEvent = await this.handleAfterAgentCallback(ctx);
-    if (afterEvent) {
-      yield afterEvent;
+    const startTime = Date.now();
+    let status = "success";
+    try {
+      if (!ctx.transferContext) {
+        ctx.transferContext = {
+          transferChain: [this.name],
+          transferDepth: 0,
+          rootAgentName: this.name
+        };
+      } else {
+        const previousAgentName = ctx.transferContext.transferChain[ctx.transferContext.transferChain.length - 1];
+        telemetryService.addEvent("agent_transfer_received", {
+          source_agent: previousAgentName,
+          transfer_chain: JSON.stringify(ctx.transferContext.transferChain),
+          transfer_depth: ctx.transferContext.transferDepth
+        });
+        ctx.transferContext = {
+          ...ctx.transferContext,
+          transferChain: [...ctx.transferContext.transferChain, this.name],
+          transferDepth: ctx.transferContext.transferDepth + 1
+        };
+      }
+      const lastUserEvent = ctx.session.events.slice().reverse().find((e) => e.author === "user");
+      const input = extractTextFromContent(lastUserEvent?.content);
+      telemetryService.traceAgentInvocation(
+        { name: this.name, description: this.description },
+        ctx,
+        input
+      );
+      if (ctx.transferContext.transferDepth > 0) {
+        telemetryService.setActiveSpanAttributes({
+          "adk.agent.depth": ctx.transferContext.transferDepth,
+          "adk.transfer.chain": JSON.stringify(
+            ctx.transferContext.transferChain
+          ),
+          "adk.transfer.depth": ctx.transferContext.transferDepth,
+          "adk.transfer.root_agent": ctx.transferContext.rootAgentName
+        });
+      }
+      telemetryService.recordAgentInvocation({
+        agentName: this.name,
+        environment: process.env.NODE_ENV,
+        status: "success"
+      });
+      const beforeEvent = await this.handleBeforeAgentCallback(ctx);
+      if (beforeEvent) {
+        yield beforeEvent;
+      }
+      if (ctx.endInvocation) {
+        return;
+      }
+      for await (const event of this.runAsyncImpl(ctx)) {
+        yield event;
+      }
+      if (ctx.endInvocation) {
+        return;
+      }
+      const afterEvent = await this.handleAfterAgentCallback(ctx);
+      if (afterEvent) {
+        yield afterEvent;
+      }
+      const lastAgentEvent = ctx.session.events.slice().reverse().find((e) => e.author === this.name);
+      const output = extractTextFromContent(lastAgentEvent?.content);
+      if (output) {
+        telemetryService.setActiveSpanAttributes({
+          ["gen_ai.output.messages"]: output
+        });
+        telemetryService.addEvent("gen_ai.agent.output", {
+          "gen_ai.output": output
+        });
+      }
+    } catch (error) {
+      status = "error";
+      telemetryService.recordError("agent", this.name);
+      throw error;
+    } finally {
+      const durationMs = Date.now() - startTime;
+      telemetryService.recordAgentDuration(durationMs, {
+        agentName: this.name,
+        environment: process.env.NODE_ENV,
+        status
+      });
     }
   }
   /**
@@ -9404,11 +11028,29 @@ var BaseAgent = class {
       callbackContext
     });
     if (!beforeAgentCallbackContent && this.canonicalBeforeAgentCallbacks.length > 0) {
-      for (const callback of this.canonicalBeforeAgentCallbacks) {
-        let result = callback(callbackContext);
-        if (result instanceof Promise) {
-          result = await result;
-        }
+      for (let i = 0; i < this.canonicalBeforeAgentCallbacks.length; i++) {
+        const callback = this.canonicalBeforeAgentCallbacks[i];
+        const result = await telemetryService.withSpan(
+          `callback [before_agent] ${this.name}`,
+          async (_span) => {
+            telemetryService.traceCallback(
+              "before_agent",
+              callback.name,
+              i,
+              ctx
+            );
+            let callbackResult = callback(callbackContext);
+            if (callbackResult instanceof Promise) {
+              callbackResult = await callbackResult;
+            }
+            if (callbackResult) {
+              telemetryService.setActiveSpanAttributes({
+                "adk.callback.override_returned": true
+              });
+            }
+            return callbackResult;
+          }
+        );
         if (result) {
           beforeAgentCallbackContent = result;
           break;
@@ -9449,11 +11091,29 @@ var BaseAgent = class {
       callbackContext
     });
     if (!afterAgentCallbackContent && this.canonicalAfterAgentCallbacks.length > 0) {
-      for (const callback of this.canonicalAfterAgentCallbacks) {
-        let result = callback(callbackContext);
-        if (result instanceof Promise) {
-          result = await result;
-        }
+      for (let i = 0; i < this.canonicalAfterAgentCallbacks.length; i++) {
+        const callback = this.canonicalAfterAgentCallbacks[i];
+        const result = await telemetryService.withSpan(
+          `callback [after_agent] ${this.name}`,
+          async (_span) => {
+            telemetryService.traceCallback(
+              "after_agent",
+              callback.name,
+              i,
+              invocationContext
+            );
+            let callbackResult = callback(callbackContext);
+            if (callbackResult instanceof Promise) {
+              callbackResult = await callbackResult;
+            }
+            if (callbackResult) {
+              telemetryService.setActiveSpanAttributes({
+                "adk.callback.override_returned": true
+              });
+            }
+            return callbackResult;
+          }
+        );
         if (result) {
           afterAgentCallbackContent = result;
           break;
@@ -10211,8 +11871,8 @@ var InMemoryMemoryService = class {
 };
 
 // src/plugins/plugin-manager.ts
-import { z as z3 } from "zod";
-var pluginCallbackNameSchema = z3.enum([
+import { z as z4 } from "zod";
+var pluginCallbackNameSchema = z4.enum([
   "onUserMessageCallback",
   "beforeRunCallback",
   "afterRunCallback",
@@ -10763,7 +12423,14 @@ var Runner = class {
     runConfig = new RunConfig()
   }) {
     const span = tracer.startSpan("invocation");
-    const spanContext = trace3.setSpan(context3.active(), span);
+    const spanContext = trace4.setSpan(context3.active(), span);
+    const inputText = extractTextFromContent(newMessage);
+    if (inputText && telemetryService.shouldCaptureContent()) {
+      span.setAttribute(SEMCONV.GEN_AI_INPUT_MESSAGES, inputText);
+      span.addEvent("gen_ai.invocation.input", {
+        "gen_ai.input": inputText
+      });
+    }
     try {
       const session = await context3.with(
         spanContext,
@@ -10812,6 +12479,14 @@ var Runner = class {
         }
         yield event;
       }
+      const lastAgentEvent = session.events.slice().reverse().find((e) => e.author && e.author !== "user");
+      const outputText = extractTextFromContent(lastAgentEvent?.content);
+      if (outputText && telemetryService.shouldCaptureContent()) {
+        span.setAttribute(SEMCONV.GEN_AI_OUTPUT_MESSAGES, outputText);
+        span.addEvent("gen_ai.invocation.output", {
+          "gen_ai.output": outputText
+        });
+      }
       await context3.with(
         spanContext,
         () => this._runCompaction(session, invocationContext)
@@ -12612,7 +14287,7 @@ var VertexAiEvalFacade = class _VertexAiEvalFacade {
     }
     return 3 /* NOT_EVALUATED */;
   }
-  static async _performEval(dataset, metrics) {
+  static async _performEval(dataset, metrics3) {
     const projectId = process.env.GOOGLE_CLOUD_PROJECT;
     const location = process.env.GOOGLE_CLOUD_LOCATION;
     if (!projectId) {
@@ -14139,10 +15814,10 @@ var LangfusePlugin = class extends BasePlugin {
     return `${invocationId}:gen:${model || "unknown"}`;
   }
   getOrCreateTrace(ctx) {
-    let trace4 = this.traces.get(ctx.invocationId);
-    if (trace4) return trace4;
+    let trace5 = this.traces.get(ctx.invocationId);
+    if (trace5) return trace5;
     const userInput = this.toPlainText(ctx.userContent);
-    trace4 = this.client.trace({
+    trace5 = this.client.trace({
       id: ctx.invocationId,
       name: `${ctx.agent.name}-session`,
       userId: ctx.userId,
@@ -14155,14 +15830,14 @@ var LangfusePlugin = class extends BasePlugin {
         agentType: ctx.agent.constructor.name
       }
     });
-    this.traces.set(ctx.invocationId, trace4);
-    return trace4;
+    this.traces.set(ctx.invocationId, trace5);
+    return trace5;
   }
   async onUserMessageCallback(params) {
-    const trace4 = this.getOrCreateTrace(params.invocationContext);
+    const trace5 = this.getOrCreateTrace(params.invocationContext);
     const userInput = this.toPlainText(params.userMessage);
-    trace4.update({ input: userInput });
-    trace4.event({
+    trace5.update({ input: userInput });
+    trace5.event({
       name: "user_message",
       input: this.serializeContent(params.userMessage),
       metadata: {
@@ -14172,8 +15847,8 @@ var LangfusePlugin = class extends BasePlugin {
     return void 0;
   }
   async beforeRunCallback(params) {
-    const trace4 = this.getOrCreateTrace(params.invocationContext);
-    trace4.event({
+    const trace5 = this.getOrCreateTrace(params.invocationContext);
+    trace5.event({
       name: "run_start",
       metadata: {
         agentName: params.invocationContext.agent.name,
@@ -14184,14 +15859,14 @@ var LangfusePlugin = class extends BasePlugin {
     return void 0;
   }
   async onEventCallback(params) {
-    const trace4 = this.getOrCreateTrace(params.invocationContext);
+    const trace5 = this.getOrCreateTrace(params.invocationContext);
     const agentSpan = this.agentSpans.get(
       this.getAgentSpanKey(
         params.invocationContext.invocationId,
         params.event.author
       )
     );
-    const parent = agentSpan || trace4;
+    const parent = agentSpan || trace5;
     const eventText = this.toPlainText(params.event.content);
     if (params.event.content?.parts?.some((p) => p.text || p.codeExecutionResult)) {
       this.lastEventByInvocation.set(
@@ -14219,8 +15894,8 @@ var LangfusePlugin = class extends BasePlugin {
     return void 0;
   }
   async afterRunCallback(params) {
-    const trace4 = this.traces.get(params.invocationContext.invocationId);
-    if (!trace4) return;
+    const trace5 = this.traces.get(params.invocationContext.invocationId);
+    if (!trace5) return;
     const lastEvent = this.lastEventByInvocation.get(
       params.invocationContext.invocationId
     );
@@ -14242,7 +15917,7 @@ var LangfusePlugin = class extends BasePlugin {
       }
     }
     if (output || outputText) {
-      trace4.update({
+      trace5.update({
         output: outputText || output,
         metadata: {
           outputText,
@@ -14250,7 +15925,7 @@ var LangfusePlugin = class extends BasePlugin {
           resultType: lastEvent ? "event" : typeof params.result
         }
       });
-      trace4.event({
+      trace5.event({
         name: "run_complete",
         output,
         metadata: {
@@ -14261,7 +15936,7 @@ var LangfusePlugin = class extends BasePlugin {
     }
     const usage = this.tokenUsage.get(params.invocationContext.invocationId);
     if (usage) {
-      trace4.update({
+      trace5.update({
         metadata: {
           usage: {
             input: usage.inputTokens,
@@ -14289,7 +15964,7 @@ var LangfusePlugin = class extends BasePlugin {
     }
   }
   async beforeAgentCallback(params) {
-    const trace4 = this.getOrCreateTrace(
+    const trace5 = this.getOrCreateTrace(
       params.callbackContext.invocationContext
     );
     const agentSpanKey = this.getAgentSpanKey(
@@ -14306,7 +15981,7 @@ var LangfusePlugin = class extends BasePlugin {
         parentAgent.name
       )
     ) : void 0;
-    const parent = parentSpan || trace4;
+    const parent = parentSpan || trace5;
     const span = parent.span({
       name: params.agent.name,
       input,
@@ -15609,6 +17284,8 @@ function createDatabaseSessionService(databaseUrl, options) {
 // src/version.ts
 var VERSION = "0.1.0";
 export {
+  ADK_ATTRS,
+  ADK_SYSTEM_NAME,
   AF_FUNCTION_CALL_ID_PREFIX,
   LlmAgent as Agent,
   AgentBuilder,
@@ -15645,7 +17322,9 @@ export {
   CallbackContext,
   CodeExecutionUtils,
   CodeExecutorContext,
+  DEFAULTS,
   DatabaseSessionService,
+  ENV_VARS,
   EnhancedAuthConfig,
   EvalResult,
   EvalStatus,
@@ -15682,6 +17361,7 @@ export {
   LoadMemoryTool,
   LocalEvalService,
   LoopAgent,
+  METRICS,
   McpAbi,
   McpAtp,
   McpBamm,
@@ -15707,6 +17387,7 @@ export {
   models_exports as Models,
   OAuth2Credential,
   OAuth2Scheme,
+  OPERATIONS,
   OpenAiLlm,
   OpenIdConnectScheme,
   ParallelAgent,
@@ -15720,6 +17401,7 @@ export {
   RougeEvaluator,
   RunConfig,
   Runner,
+  SEMCONV,
   SafetyEvaluatorV1,
   SequentialAgent,
   sessions_exports as Sessions,
@@ -15740,6 +17422,8 @@ export {
   requestProcessor8 as agentTransferRequestProcessor,
   requestProcessor2 as basicRequestProcessor,
   buildFunctionDeclaration,
+  buildLlmRequestForTrace,
+  buildLlmResponseForTrace,
   requestProcessor3 as codeExecutionRequestProcessor,
   responseProcessor as codeExecutionResponseProcessor,
   requestProcessor4 as contentRequestProcessor,
@@ -15753,9 +17437,12 @@ export {
   createSamplingHandler,
   createSqliteSessionService,
   createTool,
+  extractTextFromContent,
+  formatSpanAttributes,
   generateAuthEvent,
   generateClientFunctionCallId,
   getArtifactUri,
+  getEnvironment,
   getLongRunningFunctionCalls,
   getMcpTools,
   handleFunctionCallsAsync,
@@ -15777,12 +17464,18 @@ export {
   parseArtifactUri,
   pluginCallbackNameSchema,
   populateClientFunctionCallId,
+  recordAgentInvocation,
+  recordLlmCall,
+  recordToolExecution,
   registerProviders,
   removeClientFunctionCallId,
   requestProcessor,
   runCompactionForSlidingWindow,
+  safeJsonStringify,
+  shouldCaptureContent,
   shutdownTelemetry,
   telemetryService,
+  traceAgentInvocation,
   traceLlmCall,
   traceToolCall,
   tracer