@opensearch-project/agent-health 0.3.0 → 0.4.0

package/server/dist/app.js

@@ -87,6 +87,8 @@ var init_config = __esm({
       // OpenAI-compatible (optional - for OpenAI-compatible judge/agent endpoints)
       openaiCompatibleApiKey: getEnvVar("OPENAI_COMPATIBLE_API_KEY", ""),
       openaiCompatibleEndpoint: getEnvVar("OPENAI_COMPATIBLE_ENDPOINT", "http://localhost:4000/v1/chat/completions"),
+      // Observio Sample Agent endpoint
+      observioEndpoint: getEnvVar("OBSERVIO_ENDPOINT", "http://localhost:3001/run-agent"),
       // Claude Code Telemetry (optional - for OTEL traces from Claude Code)
       claudeCodeTelemetryEnabled: getEnvVar("CLAUDE_CODE_TELEMETRY_ENABLED", "false") === "true",
       otelExporterEndpoint: getEnvVar("OTEL_EXPORTER_OTLP_ENDPOINT", ""),
@@ -151,6 +153,16 @@ var init_constants = __esm({
         description: "Invokes the Claude Code CLI. Server-only \u2014 use the CLI or benchmark runner.",
         serverOnly: true
       },
+      "strands": {
+        label: "Amazon Strands",
+        description: "Amazon Strands agent framework via Bedrock Agent Runtime API. Server-only \u2014 requires AWS SDK.",
+        serverOnly: true
+      },
+      "langgraph": {
+        label: "LangGraph (REST)",
+        description: "LangGraph agent via direct REST API. Use for non-AG-UI LangGraph instances.",
+        serverOnly: false
+      },
       "mock": {
         label: "Mock",
         description: "Built-in demo agent for testing. No real endpoint needed.",
@@ -170,6 +182,15 @@ var init_constants = __esm({
           headers: {},
           useTraces: false
         },
+        {
+          key: "observio",
+          name: "Observio Sample Agent",
+          endpoint: ENV_CONFIG.observioEndpoint || "http://localhost:3001/run-agent",
+          description: "Observio sample agent \u2014 ReAct pattern with LangGraph and Bedrock. Start with: cd observio-sample-agent && npm run start:ag-ui",
+          connectorType: "agui-streaming",
+          headers: {},
+          useTraces: true
+        },
         {
           key: "claude-code",
           name: "Claude Code",
@@ -179,6 +200,30 @@ var init_constants = __esm({
           headers: {},
           useTraces: ENV_CONFIG.claudeCodeTelemetryEnabled && !!ENV_CONFIG.otelExporterEndpoint,
           connectorConfig: { env: getClaudeCodeConnectorEnv() }
+        },
+        {
+          key: "strands",
+          name: "Amazon Strands",
+          endpoint: "${STRANDS_AGENT_ID}",
+          description: "Amazon Strands agent framework (Bedrock Agent Runtime)",
+          connectorType: "strands",
+          headers: {},
+          useTraces: false,
+          connectorConfig: {
+            agentAliasId: "${STRANDS_ALIAS_ID:-TSTALIASID}",
+            region: "${AWS_REGION:-us-east-1}"
+          },
+          enabled: false
+        },
+        {
+          key: "langgraph-rest",
+          name: "LangGraph (REST)",
+          endpoint: "${LANGGRAPH_API_ENDPOINT:-http://localhost:8000}",
+          description: "LangGraph agent via direct REST API",
+          connectorType: "langgraph",
+          headers: {},
+          useTraces: false,
+          enabled: false
         }
       ],
       models: {
@@ -362,6 +407,7 @@ function mergeConfigs(userConfig, defaultConfig) {
     ...DEFAULT_SERVER_CONFIG,
     ...userConfig.server
   };
+  const telemetry = userConfig.telemetry ?? {};
   return {
     server,
     agents,
@@ -369,7 +415,8 @@ function mergeConfigs(userConfig, defaultConfig) {
     connectors,
     testCases,
     reporters,
-    judge
+    judge,
+    telemetry
   };
 }
 async function loadUserConfig(configPath) {
@@ -411,7 +458,8 @@ function loadConfigSync(cwd = process.cwd()) {
     connectors: [],
     testCases: [],
     reporters: [["console"]],
-    judge: { provider: "bedrock", model: "claude-sonnet-4" }
+    judge: { provider: "bedrock", model: "claude-sonnet-4" },
+    telemetry: {}
   };
 }
 function clearConfigCache() {
@@ -1129,7 +1177,8 @@ var ClaudeCodeReader = class {
       if (s.session_completed) completedSessions++;
       const toolCallCount = Object.values(s.tool_counts).reduce((a, b) => a + b, 0);
       totalToolCalls += toolCallCount;
-      const date = s.start_time.slice(0, 10);
+      const _d = new Date(s.start_time);
+      const date = `${_d.getFullYear()}-${String(_d.getMonth() + 1).padStart(2, "0")}-${String(_d.getDate()).padStart(2, "0")}`;
       if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
         const existing = dailyMap.get(date) ?? { date, messageCount: 0, sessionCount: 0, toolCallCount: 0 };
         existing.messageCount += s.user_message_count + s.assistant_message_count;
@@ -2017,7 +2066,8 @@ var KiroReader = class {
       if (s.session_completed) completedSessions++;
       const toolCallCount = Object.values(s.tool_counts).reduce((a, b) => a + b, 0);
       totalToolCalls += toolCallCount;
-      const date = s.start_time.slice(0, 10);
+      const _d = new Date(s.start_time);
+      const date = `${_d.getFullYear()}-${String(_d.getMonth() + 1).padStart(2, "0")}-${String(_d.getDate()).padStart(2, "0")}`;
       if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
         const existing = dailyMap.get(date) ?? { date, messageCount: 0, sessionCount: 0, toolCallCount: 0 };
         existing.messageCount += s.user_message_count + s.assistant_message_count;
@@ -2362,7 +2412,8 @@ var CodexReader = class {
       if (s.session_completed) completedSessions++;
       const toolCallCount = Object.values(s.tool_counts).reduce((a, b) => a + b, 0);
       totalToolCalls += toolCallCount;
-      const date = s.start_time.slice(0, 10);
+      const _d = new Date(s.start_time);
+      const date = `${_d.getFullYear()}-${String(_d.getMonth() + 1).padStart(2, "0")}-${String(_d.getDate()).padStart(2, "0")}`;
       if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
         const existing = dailyMap.get(date) ?? { date, messageCount: 0, sessionCount: 0, toolCallCount: 0 };
         existing.messageCount += s.user_message_count + s.assistant_message_count;
@@ -2809,7 +2860,7 @@ function localDateStr(d) {
 function filterByDate(sessions, range) {
   if (!range?.from && !range?.to) return sessions;
   return sessions.filter((s) => {
-    const date = s.start_time.slice(0, 10);
+    const date = localDateStr(new Date(s.start_time));
     if (range.from && date < range.from) return false;
     if (range.to && date > range.to) return false;
     return true;
@@ -2835,7 +2886,7 @@ function computeStatsFromSessions(sessions, agent) {
     if (s.session_completed) completedSessions++;
     const toolCallCount = Object.values(s.tool_counts).reduce((a, b) => a + b, 0);
     totalToolCalls += toolCallCount;
-    const date = s.start_time.slice(0, 10);
+    const date = localDateStr(new Date(s.start_time));
     if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
       const existing = dailyMap.get(date) ?? { date, messageCount: 0, sessionCount: 0, toolCallCount: 0 };
       existing.messageCount += s.user_message_count + s.assistant_message_count;
@@ -3004,7 +3055,7 @@ var CodingAgentRegistry = class {
     }
     const dailyCostMap = /* @__PURE__ */ new Map();
     for (const s of sessions) {
-      const date = s.start_time.slice(0, 10);
+      const date = localDateStr(new Date(s.start_time));
       if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
       const key = `${date}:${s.agent}`;
       const existing = dailyCostMap.get(key) ?? { date, cost: 0, agent: s.agent };
@@ -3032,7 +3083,7 @@ var CodingAgentRegistry = class {
       if (!s.start_time) continue;
       const d = new Date(s.start_time);
       if (isNaN(d.getTime())) continue;
-      activeDates.add(s.start_time.slice(0, 10));
+      activeDates.add(localDateStr(new Date(s.start_time)));
       dowCounts[d.getDay()]++;
       hourCounts[d.getHours()]++;
     }
@@ -3059,7 +3110,7 @@ var CodingAgentRegistry = class {
     }
     const dailyMap = /* @__PURE__ */ new Map();
     for (const s of sessions) {
-      const date = s.start_time.slice(0, 10);
+      const date = localDateStr(new Date(s.start_time));
       if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
       const existing = dailyMap.get(date) ?? { date, messageCount: 0, sessionCount: 0, toolCallCount: 0 };
       existing.messageCount += s.user_message_count + s.assistant_message_count;
@@ -3178,7 +3229,7 @@ var CodingAgentRegistry = class {
       const totalDuration = data.sessions.reduce((s, sess) => s + sess.duration_minutes, 0);
       const dailyCostMap = /* @__PURE__ */ new Map();
       for (const s of data.sessions) {
-        const date = s.start_time.slice(0, 10);
+        const date = localDateStr(new Date(s.start_time));
         if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
         const key = `${date}:${s.agent}`;
         const existing = dailyCostMap.get(key) ?? { date, cost: 0, agent: s.agent };
@@ -3387,7 +3438,7 @@ var CodingAgentRegistry = class {
       const totalToolErrors = userSessions.reduce((s, sess) => s + sess.total_tool_errors, 0);
       const totalDuration = userSessions.reduce((s, sess) => s + sess.duration_minutes, 0);
       const agents = [...new Set(userSessions.map((s) => s.agent))];
-      const activeDates = new Set(userSessions.map((s) => s.start_time.slice(0, 10)));
+      const activeDates = new Set(userSessions.map((s) => localDateStr(new Date(s.start_time))));
       const projectCounts = /* @__PURE__ */ new Map();
       for (const s of userSessions) {
         projectCounts.set(s.project_path, (projectCounts.get(s.project_path) ?? 0) + 1);
@@ -3495,9 +3546,10 @@ var RemoteAggregator = class extends CodingAgentRegistry {
   filterByRange(sessions, range) {
     if (!range?.from && !range?.to) return sessions;
     return sessions.filter((s) => {
-      const t = s.start_time;
-      if (range.from && t < range.from) return false;
-      if (range.to && t > range.to + "T23:59:59") return false;
+      const y = new Date(s.start_time);
+      const date = `${y.getFullYear()}-${String(y.getMonth() + 1).padStart(2, "0")}-${String(y.getDate()).padStart(2, "0")}`;
+      if (range.from && date < range.from) return false;
+      if (range.to && date > range.to) return false;
       return true;
     });
   }
@@ -4104,15 +4156,15 @@ router2.post("/api/judge", async (req, res) => {
     if (!modelConfig) {
       modelConfig = Object.values(config2.models).find((m) => m.model_id === modelId);
     }
-    const provider = modelConfig?.provider || "bedrock";
+    const provider2 = modelConfig?.provider || "bedrock";
     const resolvedModelId = modelConfig?.model_id || modelId;
-    debug("JudgeAPI", "Using provider:", provider, "model:", resolvedModelId);
-    if (provider === "demo") {
+    debug("JudgeAPI", "Using provider:", provider2, "model:", resolvedModelId);
+    if (provider2 === "demo") {
       debug("JudgeAPI", "Demo provider - returning mock evaluation");
       const mockResult = generateMockEvaluation(trajectory, expectedOutcomes);
       return res.json(mockResult);
     }
-    if (provider === "openai-compatible") {
+    if (provider2 === "openai-compatible") {
       debug("JudgeAPI", "OpenAI-compatible provider - calling endpoint");
       const result2 = await evaluateWithOpenAICompatible(
         { trajectory, expectedOutcomes, expectedTrajectory, logs },
@@ -4129,7 +4181,7 @@ router2.post("/api/judge", async (req, res) => {
     res.json(result);
   } catch (error) {
     console.error("[JudgeAPI] Error during evaluation:", error);
-    const provider = (() => {
+    const provider2 = (() => {
       try {
         const config2 = loadConfigSync();
         const { modelId } = req.body;
@@ -4139,7 +4191,7 @@ router2.post("/api/judge", async (req, res) => {
         return "bedrock";
       }
     })();
-    const errorMessage = provider === "openai-compatible" ? parseOpenAICompatibleError(error) : parseBedrockError(error);
+    const errorMessage = provider2 === "openai-compatible" ? parseOpenAICompatibleError(error) : parseBedrockError(error);
     res.status(500).json({
       error: `Judge evaluation failed: ${errorMessage}`,
       details: error.message
@@ -4430,13 +4482,13 @@ function getCustomAgents() {
 }
 
 // lib/hooks.ts
-async function executeBeforeRequestHook(hooks, context, agentKey) {
+async function executeBeforeRequestHook(hooks, context2, agentKey) {
   if (!hooks?.beforeRequest) {
-    return context;
+    return context2;
   }
   debug("Hooks", `Executing beforeRequest hook for agent "${agentKey}"`);
   try {
-    const result = await hooks.beforeRequest(context);
+    const result = await hooks.beforeRequest(context2);
     if (!result || typeof result !== "object") {
       throw new Error("beforeRequest hook must return an object with endpoint, payload, and headers");
     }
@@ -4456,12 +4508,12 @@ async function executeBeforeRequestHook(hooks, context, agentKey) {
     throw new Error(`beforeRequest hook failed for agent "${agentKey}": ${message}`);
   }
 }
-async function executeAfterResponseHook(hooks, context, agentKey) {
+async function executeAfterResponseHook(hooks, context2, agentKey) {
   if (!hooks?.afterResponse) {
-    return context;
+    return context2;
   }
   try {
-    const result = await hooks.afterResponse(context);
+    const result = await hooks.afterResponse(context2);
     if (!result || typeof result !== "object") {
       throw new Error("afterResponse hook must return an object with response, trajectory, and optional runId");
     }
@@ -4477,12 +4529,12 @@ async function executeAfterResponseHook(hooks, context, agentKey) {
     throw new Error(`afterResponse hook failed for agent "${agentKey}": ${message}`);
   }
 }
-async function executeBuildTrajectoryHook(hooks, context, agentKey) {
+async function executeBuildTrajectoryHook(hooks, context2, agentKey) {
   if (!hooks?.buildTrajectory) {
     return null;
   }
   try {
-    const result = await hooks.buildTrajectory(context);
+    const result = await hooks.buildTrajectory(context2);
     if (result !== null && !Array.isArray(result)) {
       throw new Error("buildTrajectory hook must return an array of TrajectoryStep objects or null");
     }
@@ -4533,6 +4585,36 @@ var agent_default = router3;
 import { Router as Router4 } from "express";
 
 // server/services/tracesService.ts
+function classifyOpenSearchError(error) {
+  const statusCode = error.meta?.statusCode;
+  const message = error.message || "Unknown error";
+  if (statusCode === 401 || statusCode === 403) {
+    return {
+      category: "auth",
+      message: `Authentication failed (HTTP ${statusCode})`,
+      suggestion: "AWS credentials may be expired or invalid. Run `aws sts get-caller-identity` to verify, then refresh with `aws sso login` or update your credentials."
+    };
+  }
+  if (statusCode === 404) {
+    return {
+      category: "index_not_found",
+      message: "Trace index not found",
+      suggestion: "The OpenSearch traces index does not exist yet. Ensure your agents are configured to emit OpenTelemetry spans."
+    };
+  }
+  if (message.includes("ECONNREFUSED") || message.includes("ENOTFOUND") || message.includes("getaddrinfo") || message.includes("Connection refused")) {
+    return {
+      category: "connection",
+      message: `Cannot connect to OpenSearch: ${message}`,
+      suggestion: "Check that the OpenSearch endpoint is correct and the cluster is reachable from your network."
+    };
+  }
+  return {
+    category: "unknown",
+    message,
+    suggestion: "Check the server logs for more details."
+  };
+}
 function transformSpan(source) {
   const attributes = {};
   for (const [key, value] of Object.entries(source)) {
@@ -4587,11 +4669,11 @@ function transformSpan(source) {
   };
 }
 async function fetchTraces(options, client, indexPattern = "otel-v1-apm-span-*") {
-  const { traceId, runIds, startTime, endTime, size = 100, serviceName, textSearch, cursor } = options;
+  const { traceId, runIds, sessionId, startTime, endTime, size = 100, serviceName, textSearch, cursor } = options;
   const hasTimeRange = startTime || endTime;
-  const hasIdFilter = traceId || runIds && runIds.length > 0;
+  const hasIdFilter = traceId || runIds && runIds.length > 0 || sessionId;
   if (!hasIdFilter && !hasTimeRange) {
-    throw new Error("Either traceId, runIds, or time range is required");
+    throw new Error("Either traceId, runIds, sessionId, or time range is required");
   }
   debug("TracesService", "Fetching traces:", { traceId, runIds: runIds?.length, serviceName, textSearch, size, cursor: cursor ? "present" : "none" });
   const must = [];
@@ -4603,6 +4685,9 @@ async function fetchTraces(options, client, indexPattern = "otel-v1-apm-span-*")
       terms: { "span.attributes.gen_ai@request@id": runIds }
     });
   }
+  if (sessionId) {
+    must.push({ term: { "span.attributes.session@id": sessionId } });
+  }
   if (startTime || endTime) {
     const range = { "startTime": {} };
     if (startTime) range["startTime"].gte = new Date(startTime).toISOString();
@@ -4674,7 +4759,13 @@ async function checkTracesHealth(client, indexPattern = "otel-v1-apm-span-*") {
       return { status: "error", index: indexPattern };
     }
   } catch (error) {
-    return { status: "error", error: error.message };
+    const classified = classifyOpenSearchError(error);
+    return {
+      status: "error",
+      error: classified.message,
+      errorCategory: classified.category,
+      suggestion: classified.suggestion
+    };
   }
 }
 
@@ -6328,10 +6419,10 @@ function createOpenSearchClient(config2) {
       region: config2.awsRegion,
       service: config2.awsService || "es",
       getCredentials: () => {
-        const provider = fromNodeProviderChain2({
+        const provider2 = fromNodeProviderChain2({
           ...config2.awsProfile && { profile: config2.awsProfile }
         });
-        return provider();
+        return provider2();
       }
     });
     return new Client({
@@ -7252,15 +7343,19 @@ var OpenSearchRunOperations = class {
   async getAll(options) {
     const size = options?.size ?? 100;
     const from = options?.from ?? 0;
+    const body = {
+      size,
+      from,
+      sort: [{ createdAt: { order: "desc" } }],
+      query: { match_all: {} }
+    };
+    if (options?._source && options._source.length > 0) {
+      body._source = options._source;
+    }
     try {
       const result = await this.client.search({
         index: this.index,
-        body: {
-          size,
-          from,
-          sort: [{ createdAt: { order: "desc" } }],
-          query: { match_all: {} }
-        }
+        body
       });
       const items = hitsToSources(result.body.hits?.hits || []);
       const total = typeof result.body.hits?.total === "object" ? result.body.hits.total.value : result.body.hits?.total ?? 0;
@@ -7964,8 +8059,12 @@ function resolveObservabilityConfig(req) {
   if (fileConfig) {
     return {
       endpoint: fileConfig.endpoint,
+      authType: fileConfig.authType,
       username: fileConfig.username,
       password: fileConfig.password,
+      awsProfile: fileConfig.awsProfile,
+      awsRegion: fileConfig.awsRegion,
+      awsService: fileConfig.awsService,
       tlsSkipVerify: fileConfig.tlsSkipVerify,
       indexes: {
         traces: fileConfig.indexes?.traces || DEFAULT_OTEL_INDEXES.traces,
@@ -8009,14 +8108,34 @@ function getStorageConfigFromEnv() {
     awsService: process.env.OPENSEARCH_STORAGE_AWS_SERVICE || void 0
   };
 }
+function getObservabilityConfigFromEnv() {
+  const endpoint = process.env.OPENSEARCH_LOGS_ENDPOINT;
+  if (!endpoint) {
+    return null;
+  }
+  return {
+    endpoint,
+    authType: process.env.OPENSEARCH_LOGS_AUTH_TYPE || void 0,
+    username: process.env.OPENSEARCH_LOGS_USERNAME,
+    password: process.env.OPENSEARCH_LOGS_PASSWORD,
+    awsProfile: process.env.OPENSEARCH_LOGS_AWS_PROFILE,
+    awsRegion: process.env.OPENSEARCH_LOGS_AWS_REGION,
+    awsService: process.env.OPENSEARCH_LOGS_AWS_SERVICE || void 0,
+    indexes: {
+      traces: process.env.OPENSEARCH_LOGS_TRACES_INDEX || DEFAULT_OTEL_INDEXES.traces,
+      logs: process.env.OPENSEARCH_LOGS_INDEX || DEFAULT_OTEL_INDEXES.logs,
+      metrics: DEFAULT_OTEL_INDEXES.metrics
+    }
+  };
+}
 
 // server/routes/traces.ts
 var router4 = Router4();
 router4.post("/api/traces", async (req, res) => {
   try {
-    const { traceId, runIds, startTime, endTime, size = 100, serviceName, textSearch, cursor } = req.body;
+    const { traceId, runIds, sessionId, startTime, endTime, size = 100, serviceName, textSearch, cursor } = req.body;
     const hasTimeRange = startTime || endTime;
-    const hasIdFilter = traceId || runIds && runIds.length > 0;
+    const hasIdFilter = traceId || runIds && runIds.length > 0 || sessionId;
     if (!hasIdFilter && !hasTimeRange) {
       return res.status(400).json({
         error: "Either traceId, runIds, or time range is required"
@@ -8030,16 +8149,18 @@ router4.post("/api/traces", async (req, res) => {
     }
     let realSpans = [];
     let warning;
+    let warningCategory;
+    let suggestion;
     let nextCursor = null;
     let hasMore = false;
     const config2 = resolveObservabilityConfig(req);
-    if (config2 && (traceId || runIds && runIds.length > 0 || startTime || endTime)) {
+    if (config2 && (traceId || runIds && runIds.length > 0 || sessionId || startTime || endTime)) {
       let client;
       try {
         client = createOpenSearchClient(config2);
         const indexPattern = config2.indexes?.traces || DEFAULT_OTEL_INDEXES.traces;
         const result = await fetchTraces(
-          { traceId, runIds, startTime, endTime, size, serviceName, textSearch, cursor },
+          { traceId, runIds, sessionId, startTime, endTime, size, serviceName, textSearch, cursor },
           client,
           indexPattern
         );
@@ -8047,8 +8168,11 @@ router4.post("/api/traces", async (req, res) => {
         nextCursor = result.nextCursor || null;
         hasMore = result.hasMore || false;
       } catch (e) {
-        console.warn("[TracesAPI] OpenSearch query failed:", e.message);
-        warning = e.message;
+        const classified = classifyOpenSearchError(e);
+        console.warn(`[TracesAPI] OpenSearch query failed (${classified.category}):`, classified.message);
+        warning = classified.message;
+        warningCategory = classified.category;
+        suggestion = classified.suggestion;
       } finally {
         if (client) {
           await client.close().catch(() => {
@@ -8074,6 +8198,8 @@ router4.post("/api/traces", async (req, res) => {
         }
       }
       warning = "Observability data source not configured";
+      warningCategory = "not_configured";
+      suggestion = "Configure OPENSEARCH_LOGS_ENDPOINT or observabilityStorage in agent-health.config.ts to connect to your traces cluster.";
     }
     const allSpans = [...sampleSpans, ...realSpans];
     res.json({
@@ -8081,7 +8207,9 @@ router4.post("/api/traces", async (req, res) => {
       total: allSpans.length,
       nextCursor,
       hasMore,
-      warning
+      warning,
+      warningCategory,
+      suggestion
     });
   } catch (error) {
     console.error("[TracesAPI] Error:", error);
@@ -8198,33 +8326,21 @@ function computeMetricsFromSampleSpans(runId) {
     status: "success"
   };
 }
-async function computeMetrics(runId, osConfig) {
-  const { endpoint, username, password, indexPattern = "otel-v1-apm-span-*" } = osConfig;
-  const query = {
-    size: 500,
-    sort: [{ startTime: { order: "asc" } }],
-    query: {
-      bool: {
-        must: [
-          { term: { "span.attributes.gen_ai@request@id": runId } }
-        ]
-      }
-    }
-  };
-  const response = await fetch(`${endpoint}/${indexPattern}/_search`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
-    },
-    body: JSON.stringify(query)
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`OpenSearch query failed: ${response.status} - ${errorText}`);
-  }
-  const data = await response.json();
-  const spans = data.hits?.hits?.map((h) => h._source) || [];
+var METRICS_SOURCE_FIELDS = [
+  "span.attributes.gen_ai@request@id",
+  "span.attributes.gen_ai@usage@input_tokens",
+  "span.attributes.gen_ai@usage@output_tokens",
+  "span.attributes.gen_ai@request@model",
+  "span.attributes.gen_ai@tool@name",
+  "span.attributes.tool.name",
+  "name",
+  "traceId",
+  "startTime",
+  "endTime",
+  "durationInNanos",
+  "status.code"
+];
+function computeMetricsFromSpans(runId, spans) {
   if (spans.length === 0) {
     return {
       runId,
@@ -8296,6 +8412,95 @@ async function computeMetrics(runId, osConfig) {
     status
   };
 }
+async function computeMetrics(runId, osConfig) {
+  const { endpoint, username, password, indexPattern = "otel-v1-apm-span-*" } = osConfig;
+  const query = {
+    size: 500,
+    sort: [{ startTime: { order: "asc" } }],
+    query: {
+      bool: {
+        must: [
+          { term: { "span.attributes.gen_ai@request@id": runId } }
+        ]
+      }
+    }
+  };
+  const response = await fetch(`${endpoint}/${indexPattern}/_search`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
+    },
+    body: JSON.stringify(query)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OpenSearch query failed: ${response.status} - ${errorText}`);
+  }
+  const data = await response.json();
+  const spans = data.hits?.hits?.map((h) => h._source) || [];
+  return computeMetricsFromSpans(runId, spans);
+}
+async function computeBatchMetrics(runIds, osConfig) {
+  if (runIds.length === 0) return [];
+  const { endpoint, username, password, indexPattern = "otel-v1-apm-span-*" } = osConfig;
+  const CHUNK_SIZE = 50;
+  const allResults = [];
+  const chunks = [];
+  for (let i = 0; i < runIds.length; i += CHUNK_SIZE) {
+    chunks.push(runIds.slice(i, i + CHUNK_SIZE));
+  }
+  const chunkResults = await Promise.all(chunks.map(async (chunk) => {
+    const query = {
+      size: 1e4,
+      sort: [{ startTime: { order: "asc" } }],
+      _source: METRICS_SOURCE_FIELDS,
+      query: {
+        bool: {
+          must: [
+            { terms: { "span.attributes.gen_ai@request@id": chunk } }
+          ]
+        }
+      }
+    };
+    const response = await fetch(`${endpoint}/${indexPattern}/_search`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
+      },
+      body: JSON.stringify(query)
+    });
+    if (!response.ok) {
+      const responseBody = await response.text();
+      console.warn(
+        `OpenSearch metrics query failed for chunk (${chunk.length} run IDs): ${response.status} ${response.statusText}. Response body: ${responseBody}`
+      );
+      return chunk.map((runId) => computeMetricsFromSpans(runId, []));
+    }
+    const data = await response.json();
+    const allSpans = data.hits?.hits?.map((h) => h._source) || [];
+    const totalHits = data.hits?.total?.value ?? allSpans.length;
+    if (totalHits > 1e4) {
+      console.warn(
+        `OpenSearch batch metrics query returned ${allSpans.length} of ${totalHits} spans for chunk of ${chunk.length} run IDs. Metrics may be incomplete.`
+      );
+    }
+    const spansByRunId = /* @__PURE__ */ new Map();
+    for (const rid of chunk) spansByRunId.set(rid, []);
+    for (const span of allSpans) {
+      const rid = span["span.attributes.gen_ai@request@id"];
+      if (rid && spansByRunId.has(rid)) {
+        spansByRunId.get(rid).push(span);
+      }
+    }
+    return chunk.map((runId) => computeMetricsFromSpans(runId, spansByRunId.get(runId) || []));
+  }));
+  for (const results of chunkResults) {
+    allResults.push(...results);
+  }
+  return allResults;
+}
 function computeAggregateMetrics(metricsArray) {
   if (!metricsArray || metricsArray.length === 0) {
     return {
@@ -8374,15 +8579,6 @@ router5.get("/api/metrics/:runId", async (req, res) => {
     res.status(500).json({ error: error.message });
   }
 });
-async function processBatches(items, batchSize, processor) {
-  const results = [];
-  for (let i = 0; i < items.length; i += batchSize) {
-    const batch = items.slice(i, i + batchSize);
-    const batchResults = await Promise.all(batch.map(processor));
-    results.push(...batchResults);
-  }
-  return results;
-}
 router5.post("/api/metrics/batch", async (req, res) => {
   try {
     const { runIds } = req.body;
@@ -8413,16 +8609,15 @@ router5.post("/api/metrics/batch", async (req, res) => {
           password: config2.password,
           indexPattern
         };
-        const BATCH_SIZE = 10;
-        realResults = await processBatches(
-          realRunIds,
-          BATCH_SIZE,
-          (runId) => computeMetrics(runId, osConfig).catch((e) => ({
+        try {
+          realResults = await computeBatchMetrics(realRunIds, osConfig);
+        } catch (e) {
+          realResults = realRunIds.map((runId) => ({
             runId,
             error: e.message,
             status: "error"
-          }))
-        );
+          }));
+        }
       }
     }
     const resultsMap = /* @__PURE__ */ new Map();
@@ -12092,11 +12287,150 @@ var OpenAICompatibleConnector = class extends BaseConnector {
 };
 var openaiCompatibleConnector = new OpenAICompatibleConnector();
 
+// services/connectors/langgraph/LangGraphConnector.ts
+var LangGraphConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "langgraph";
+    this.name = "LangGraph (REST)";
+    this.supportsStreaming = false;
+  }
+  buildPayload(request2) {
+    const config2 = request2.connectorConfig || {};
+    return {
+      input: {
+        messages: [
+          {
+            role: "user",
+            content: request2.testCase.initialPrompt
+          }
+        ]
+      },
+      config: {
+        configurable: {
+          ...request2.modelId && { model: request2.modelId },
+          ...config2.configurable
+        }
+      }
+    };
+  }
+  async execute(endpoint, request2, auth, onProgress, onRawEvent) {
+    const payload = request2.payload || this.buildPayload(request2);
+    const headers = this.buildAuthHeaders(auth);
+    const config2 = request2.connectorConfig || {};
+    const graphId = config2.graphId || "agent";
+    const baseUrl = endpoint.replace(/\/+$/, "");
+    const threadId = config2.threadId || request2.threadId;
+    const invokeUrl = threadId ? `${baseUrl}/threads/${threadId}/runs/wait` : `${baseUrl}/assistants/${graphId}/invoke`;
+    this.debug("Executing LangGraph request");
+    this.debug("URL:", invokeUrl);
+    const response = await fetch(invokeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`LangGraph request failed: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    onRawEvent?.(data);
+    const trajectory = this.parseResponse(data);
+    trajectory.forEach((step) => onProgress?.(step));
+    return {
+      trajectory,
+      runId: data.run_id || data.thread_id || threadId || null,
+      rawEvents: [data],
+      metadata: {
+        graphId,
+        threadId: data.thread_id || threadId
+      }
+    };
+  }
+  parseResponse(data) {
+    const steps = [];
+    const messages = data.output?.messages || data.values?.messages || data.messages || [];
+    for (const msg of messages) {
+      const role = msg.type || msg.role;
+      const content = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.map((c) => c.text || JSON.stringify(c)).join("\n") : JSON.stringify(msg.content);
+      if (role === "ai" || role === "assistant") {
+        if (msg.tool_calls && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+          for (const toolCall of msg.tool_calls) {
+            steps.push(this.createStep("action", `Calling ${toolCall.name}...`, {
+              toolName: toolCall.name,
+              toolArgs: toolCall.args
+            }));
+          }
+        }
+        if (content && !msg.tool_calls?.length) {
+          steps.push(this.createStep("assistant", content));
+        }
+      } else if (role === "tool") {
+        steps.push(this.createStep("tool_result", content, {
+          toolName: msg.name,
+          status: "SUCCESS"
+        }));
+      }
+    }
+    const lastAssistant = [...steps].reverse().find((s) => s.type === "assistant");
+    if (lastAssistant) {
+      lastAssistant.type = "response";
+    }
+    if (data.intermediate_steps && Array.isArray(data.intermediate_steps)) {
+      for (const [action, observation] of data.intermediate_steps) {
+        if (action?.tool) {
+          steps.push(this.createStep("action", `Calling ${action.tool}...`, {
+            toolName: action.tool,
+            toolArgs: action.tool_input
+          }));
+        }
+        if (observation !== void 0) {
+          const obsContent = typeof observation === "string" ? observation : JSON.stringify(observation);
+          steps.push(this.createStep("tool_result", obsContent, {
+            status: "SUCCESS"
+          }));
+        }
+      }
+    }
+    if (data.output && typeof data.output === "string" && steps.length === 0) {
+      steps.push(this.createStep("response", data.output));
+    }
+    if (steps.length === 0 && data) {
+      steps.push(this.createStep("response", JSON.stringify(data, null, 2)));
+    }
+    return steps;
+  }
+  async healthCheck(endpoint, auth) {
+    try {
+      const headers = this.buildAuthHeaders(auth);
+      const baseUrl = endpoint.replace(/\/+$/, "");
+      const response = await fetch(`${baseUrl}/ok`, {
+        method: "GET",
+        headers
+      });
+      return response.ok;
+    } catch {
+      try {
+        const headers = this.buildAuthHeaders(auth);
+        const response = await fetch(endpoint, { method: "GET", headers });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+  }
+};
+var langgraphConnector = new LangGraphConnector();
+
 // services/connectors/index.ts
 connectorRegistry.register(aguiStreamingConnector);
 connectorRegistry.register(mockConnector);
 connectorRegistry.register(restConnector);
 connectorRegistry.register(openaiCompatibleConnector);
+connectorRegistry.register(langgraphConnector);
 console.log("[Connectors] Browser-safe connectors registered:", connectorRegistry.getRegisteredTypes().join(", "));
 
 // services/connectors/subprocess/SubprocessConnector.ts
@@ -12140,6 +12474,7 @@ Question: ${prompt}`;
     const command = endpoint || this.config.command;
     const args = this.config.args || [];
     const input = request2.payload || this.buildPayload(request2);
+    const runId = `subprocess-${Date.now()}`;
     this.debug("Command:", command);
     this.debug("Args:", args);
     this.debug("Input mode:", this.config.inputMode);
@@ -12147,10 +12482,12 @@ Question: ${prompt}`;
     this.debug("Timeout:", this.config.timeout);
     this.debug("Input (first 500 chars):", input.substring(0, 500));
     this.debug("Working dir:", this.config.workingDir || process.cwd());
+    this.debug("Run ID:", runId);
     const env = {
       ...process.env,
       ...this.buildAuthEnv(auth),
-      ...this.config.env
+      ...this.config.env,
+      AGENT_EVAL_RUN_ID: runId
     };
     return new Promise((resolve2, reject) => {
       const trajectory = [];
@@ -12209,6 +12546,17 @@ Question: ${prompt}`;
           this.error(`Process exited with code ${code}`);
           this.error("stderr:", stderr);
         }
+        if (this.config.outputParser === "streaming") {
+          this.onBeforeStreamEnd(trajectory, onProgress);
+          if (code !== 0 && trajectory.length === 0) {
+            const errorContent = stderr.trim() ? `Error: Process exited with code ${code}. ${stderr.trim()}` : `Error: Process exited with code ${code}`;
+            const errorStep = this.createStep("tool_result", errorContent, {
+              status: "FAILURE" /* FAILURE */
+            });
+            trajectory.push(errorStep);
+            onProgress?.(errorStep);
+          }
+        }
         const finalTrajectory = this.config.outputParser === "streaming" ? trajectory : this.parseResponse({ stdout, stderr, exitCode: code });
         if (this.config.outputParser !== "streaming") {
           finalTrajectory.forEach((step) => onProgress?.(step));
@@ -12216,7 +12564,7 @@ Question: ${prompt}`;
         this.debug("Resolving with trajectory of", finalTrajectory.length, "steps");
         resolve2({
           trajectory: finalTrajectory,
-          runId: `subprocess-${Date.now()}`,
+          runId,
           rawEvents: rawOutput,
           metadata: {
             command,
@@ -12247,6 +12595,12 @@ Question: ${prompt}`;
     });
     this.debug("========== execute() COMPLETED ==========");
   }
+  /**
+   * Hook called before returning the streaming trajectory on process close.
+   * Subclasses can override to flush internal buffers.
+   */
+  onBeforeStreamEnd(_trajectory, _onProgress) {
+  }
   /**
    * Parse streaming output and emit steps in real-time
    */
@@ -12341,6 +12695,7 @@ var ClaudeCodeConnector = class extends SubprocessConnector {
     this.name = "Claude Code CLI";
     this.outputBuffer = "";
     this.thinkingBuffer = "";
+    this.textBuffer = "";
     this.isInThinking = false;
   }
   /**
@@ -12410,11 +12765,17 @@ var ClaudeCodeConnector = class extends SubprocessConnector {
       if (event.delta?.type === "thinking_delta" && event.delta.thinking) {
         this.thinkingBuffer += event.delta.thinking;
       } else if (event.delta?.type === "text_delta" && event.delta.text) {
-        steps.push(this.createStep("assistant", event.delta.text));
+        this.textBuffer += event.delta.text;
+      }
+    } else if (event.type === "content_block_stop") {
+      if (this.thinkingBuffer) {
+        steps.push(this.createStep("thinking", this.thinkingBuffer));
+        this.thinkingBuffer = "";
+      }
+      if (this.textBuffer) {
+        steps.push(this.createStep("assistant", this.textBuffer));
+        this.textBuffer = "";
       }
-    } else if (event.type === "content_block_stop" && this.thinkingBuffer) {
-      steps.push(this.createStep("thinking", this.thinkingBuffer));
-      this.thinkingBuffer = "";
     } else if (event.type === "result" && event.result) {
       steps.push(this.createStep(
         "response",
@@ -12460,8 +12821,41 @@ var ClaudeCodeConnector = class extends SubprocessConnector {
   resetState() {
     this.outputBuffer = "";
     this.thinkingBuffer = "";
+    this.textBuffer = "";
     this.isInThinking = false;
   }
+  /**
+   * Flush remaining buffers when the subprocess stream ends.
+   */
+  onBeforeStreamEnd(trajectory, onProgress) {
+    if (this.outputBuffer.trim()) {
+      try {
+        const event = JSON.parse(this.outputBuffer.trim());
+        const steps = this.parseJsonEvent(event);
+        for (const step of steps) {
+          trajectory.push(step);
+          onProgress?.(step);
+        }
+      } catch {
+        const step = this.createStep("assistant", this.outputBuffer.trim());
+        trajectory.push(step);
+        onProgress?.(step);
+      }
+      this.outputBuffer = "";
+    }
+    if (this.thinkingBuffer) {
+      const step = this.createStep("thinking", this.thinkingBuffer);
+      trajectory.push(step);
+      onProgress?.(step);
+      this.thinkingBuffer = "";
+    }
+    if (this.textBuffer) {
+      const step = this.createStep("response", this.textBuffer);
+      trajectory.push(step);
+      onProgress?.(step);
+      this.textBuffer = "";
+    }
+  }
   /**
    * Build CLI args from ClaudeCodeConnectorConfig
    */
@@ -12562,9 +12956,214 @@ var ClaudeCodeConnector = class extends SubprocessConnector {
 };
 var claudeCodeConnector = new ClaudeCodeConnector();
 
+// services/connectors/strands/StrandsConnector.ts
+var StrandsConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "strands";
+    this.name = "Amazon Strands";
+    this.supportsStreaming = true;
+  }
+  buildPayload(request2) {
+    const config2 = request2.connectorConfig || {};
+    return {
+      agentId: "",
+      // Set from endpoint in execute()
+      agentAliasId: config2.agentAliasId || "TSTALIASID",
+      sessionId: config2.sessionId || `eval-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      inputText: request2.testCase.initialPrompt,
+      enableTrace: config2.enableTrace !== false
+    };
+  }
+  async execute(endpoint, request2, auth, onProgress, onRawEvent) {
+    const payload = request2.payload || this.buildPayload(request2);
+    payload.agentId = endpoint;
+    const config2 = request2.connectorConfig || {};
+    const region = config2.region || auth.awsRegion || process.env.AWS_REGION || "us-east-1";
+    this.debug("Executing Strands agent");
+    this.debug("Agent ID:", endpoint);
+    this.debug("Alias:", payload.agentAliasId);
+    this.debug("Region:", region);
+    const { BedrockAgentRuntimeClient, InvokeAgentCommand } = await import("@aws-sdk/client-bedrock-agent-runtime");
+    const clientConfig = { region };
+    if (auth.type === "aws-sigv4" && auth.awsAccessKeyId && auth.awsSecretAccessKey) {
+      clientConfig.credentials = {
+        accessKeyId: auth.awsAccessKeyId,
+        secretAccessKey: auth.awsSecretAccessKey,
+        ...auth.awsSessionToken && { sessionToken: auth.awsSessionToken }
+      };
+    }
+    const client = new BedrockAgentRuntimeClient(clientConfig);
+    const command = new InvokeAgentCommand({
+      agentId: payload.agentId,
+      agentAliasId: payload.agentAliasId,
+      sessionId: payload.sessionId,
+      inputText: payload.inputText,
+      enableTrace: payload.enableTrace
+    });
+    const response = await client.send(command);
+    const trajectory = [];
+    let finalOutput = "";
+    if (response.completion) {
+      for await (const event of response.completion) {
+        onRawEvent?.(event);
+        if (event.chunk?.bytes) {
+          const text = new TextDecoder().decode(event.chunk.bytes);
+          finalOutput += text;
+        }
+        if (event.trace?.trace) {
+          const traceSteps = this.parseTraceEvent(event.trace.trace);
+          for (const step of traceSteps) {
+            trajectory.push(step);
+            onProgress?.(step);
+          }
+        }
+      }
+    }
+    const hasResponseFromTrace = trajectory.some((s) => s.type === "response");
+    if (finalOutput && !hasResponseFromTrace) {
+      const responseStep = this.createStep("response", finalOutput);
+      trajectory.push(responseStep);
+      onProgress?.(responseStep);
+    }
+    return {
+      trajectory,
+      runId: payload.sessionId,
+      metadata: {
+        agentId: endpoint,
+        agentAliasId: payload.agentAliasId,
+        sessionId: payload.sessionId,
+        region
+      }
+    };
+  }
+  parseResponse(rawResponse) {
+    if (rawResponse?.trace?.trace) {
+      return this.parseTraceEvent(rawResponse.trace.trace);
+    }
+    if (typeof rawResponse === "string") {
+      return [this.createStep("response", rawResponse)];
+    }
+    return [];
+  }
+  /**
+   * Parse a Bedrock Agent trace event into TrajectorySteps
+   */
+  parseTraceEvent(trace3) {
+    const steps = [];
+    if (trace3.preProcessingTrace) {
+      const pre = trace3.preProcessingTrace;
+      if (pre.modelInvocationOutput?.parsedResponse?.isValid !== void 0) {
+        steps.push(this.createStep(
+          "thinking",
+          `Pre-processing: Input ${pre.modelInvocationOutput.parsedResponse.isValid ? "valid" : "invalid"}` + (pre.modelInvocationOutput.parsedResponse.rationale ? ` \u2014 ${pre.modelInvocationOutput.parsedResponse.rationale}` : "")
+        ));
+      }
+    }
+    if (trace3.orchestrationTrace) {
+      const orch = trace3.orchestrationTrace;
+      if (orch.rationale?.text) {
+        steps.push(this.createStep("thinking", orch.rationale.text));
+      }
+      if (orch.modelInvocationInput?.text) {
+        steps.push(this.createStep("thinking", `Model input: ${this.truncate(orch.modelInvocationInput.text, 500)}`));
+      }
+      if (orch.invocationInput) {
+        const inv = orch.invocationInput;
+        if (inv.actionGroupInvocationInput) {
+          const action = inv.actionGroupInvocationInput;
+          steps.push(this.createStep("action", `Calling ${action.actionGroupName || "action"}::${action.apiPath || action.function || "invoke"}`, {
+            toolName: `${action.actionGroupName || "action"}::${action.apiPath || action.function || "invoke"}`,
+            toolArgs: action.parameters ? Object.fromEntries(
+              action.parameters.map((p) => [p.name, p.value])
+            ) : void 0
+          }));
+        }
+        if (inv.knowledgeBaseLookupInput) {
+          steps.push(this.createStep("action", `Knowledge base lookup: ${inv.knowledgeBaseLookupInput.text}`, {
+            toolName: "knowledge_base_lookup",
+            toolArgs: { query: inv.knowledgeBaseLookupInput.text }
+          }));
+        }
+      }
+      if (orch.observation) {
+        const obs = orch.observation;
+        if (obs.actionGroupInvocationOutput?.text) {
+          steps.push(this.createStep("tool_result", obs.actionGroupInvocationOutput.text, {
+            status: "SUCCESS"
+          }));
+        }
+        if (obs.knowledgeBaseLookupOutput?.retrievedReferences) {
+          const refs = obs.knowledgeBaseLookupOutput.retrievedReferences;
+          steps.push(this.createStep(
+            "tool_result",
+            `Retrieved ${refs.length} reference(s) from knowledge base`,
+            {
+              status: "SUCCESS",
+              toolOutput: refs.map((r) => ({
+                content: this.truncate(r.content?.text, 200),
+                location: r.location
+              }))
+            }
+          ));
+        }
+        if (obs.finalResponse?.text) {
+          steps.push(this.createStep("response", obs.finalResponse.text));
+        }
+      }
+    }
+    if (trace3.postProcessingTrace) {
+      const post = trace3.postProcessingTrace;
+      if (post.modelInvocationOutput?.parsedResponse?.text) {
+        steps.push(this.createStep(
+          "thinking",
+          `Post-processing: ${this.truncate(post.modelInvocationOutput.parsedResponse.text, 300)}`
+        ));
+      }
+    }
+    if (trace3.failureTrace) {
+      steps.push(this.createStep(
+        "response",
+        `Agent error: ${trace3.failureTrace.failureReason || "Unknown failure"}`
+      ));
+    }
+    return steps;
+  }
+  /**
+   * Health check: verify the agent exists via GetAgent
+   */
+  async healthCheck(endpoint, auth) {
+    try {
+      const config2 = auth;
+      const region = config2.awsRegion || process.env.AWS_REGION || "us-east-1";
+      const { BedrockAgentClient, GetAgentCommand } = await import("@aws-sdk/client-bedrock-agent");
+      const clientConfig = { region };
+      if (auth.type === "aws-sigv4" && auth.awsAccessKeyId && auth.awsSecretAccessKey) {
+        clientConfig.credentials = {
+          accessKeyId: auth.awsAccessKeyId,
+          secretAccessKey: auth.awsSecretAccessKey,
+          ...auth.awsSessionToken && { sessionToken: auth.awsSessionToken }
+        };
+      }
+      const client = new BedrockAgentClient(clientConfig);
+      const result = await client.send(new GetAgentCommand({ agentId: endpoint }));
+      return result.agent?.agentStatus === "PREPARED";
+    } catch (error) {
+      this.error("Health check failed:", error);
+      return false;
+    }
+  }
+  truncate(text, maxLen) {
+    if (!text) return "";
+    return text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
+  }
+};
+var strandsConnector = new StrandsConnector();
+
 // services/connectors/server.ts
 connectorRegistry.register(subprocessConnector);
 connectorRegistry.register(claudeCodeConnector);
+connectorRegistry.register(strandsConnector);
 console.log("[Connectors] Server connectors registered:", connectorRegistry.getRegisteredTypes().join(", "));
 
 // services/benchmarkRunner.ts
@@ -12670,6 +13269,9 @@ var runStorage = {
     const params = new URLSearchParams();
     if (options.size) params.append("size", options.size.toString());
     if (options.from) params.append("from", options.from.toString());
+    if (options._source && options._source.length > 0) {
+      params.append("fields", options._source.join(","));
+    }
     const query = params.toString() ? `?${params.toString()}` : "";
     return request("GET", `/runs${query}`);
   },
@@ -13316,7 +13918,489 @@ var TracePollingManager = class {
 };
 var tracePollingManager = new TracePollingManager();
 
+// lib/telemetry/provider.ts
+import { trace } from "@opentelemetry/api";
+import { NodeTracerProvider, BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+
+// lib/telemetry/constants.ts
+import {
+  ATTR_TEST_SUITE_NAME,
+  ATTR_TEST_SUITE_RUN_STATUS,
+  ATTR_TEST_CASE_NAME,
+  ATTR_TEST_CASE_RESULT_STATUS,
+  TEST_SUITE_RUN_STATUS_VALUE_SUCCESS,
+  TEST_SUITE_RUN_STATUS_VALUE_FAILURE,
+  TEST_SUITE_RUN_STATUS_VALUE_IN_PROGRESS,
+  TEST_CASE_RESULT_STATUS_VALUE_PASS,
+  TEST_CASE_RESULT_STATUS_VALUE_FAIL,
+  ATTR_GEN_AI_OPERATION_NAME as ATTR_GEN_AI_OPERATION_NAME4,
+  ATTR_GEN_AI_EVALUATION_NAME,
+  ATTR_GEN_AI_EVALUATION_SCORE_VALUE,
+  ATTR_GEN_AI_EVALUATION_SCORE_LABEL,
+  ATTR_GEN_AI_EVALUATION_EXPLANATION,
+  EVENT_GEN_AI_EVALUATION_RESULT
+} from "@opentelemetry/semantic-conventions/incubating";
+var ATTR_TEST_SUITE_RUN_ID = "test.suite.run.id";
+var ATTR_TEST_CASE_ID = "test.case.id";
+var ATTR_TEST_CASE_INPUT = "test.case.input";
+var ATTR_TEST_CASE_OUTPUT = "test.case.output";
+var ATTR_TEST_CASE_EXPECTED = "test.case.expected";
+var ATTR_AGENT_HEALTH_JUDGE_MODEL_ID = "agent_health.judge.model_id";
+var ATTR_AGENT_HEALTH_JUDGE_DURATION_MS = "agent_health.judge.duration_ms";
+var ATTR_AGENT_HEALTH_JUDGE_ATTEMPTS = "agent_health.judge.attempts";
+var ATTR_AGENT_HEALTH_AGENT_DURATION_MS = "agent_health.agent.duration_ms";
+var ATTR_AGENT_HEALTH_CONNECTOR_PROTOCOL = "agent_health.connector.protocol";
+var ATTR_AGENT_HEALTH_AGENT_RUN_ID = "gen_ai.request.id";
+var GEN_AI_OPERATION_NAME_VALUE_EVALUATION = "evaluation";
+var MAX_ATTRIBUTE_LENGTH = 1e4;
+var MAX_EXPLANATION_LENGTH = 4e3;
+var EVAL_TRACER_NAME = "agent-health-eval";
+
+// lib/telemetry/opensearchExporter.ts
+import { ExportResultCode } from "@opentelemetry/core";
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { Client as Client2 } from "@opensearch-project/opensearch";
+function hrTimeToDate(hrTime) {
+  const ms = hrTime[0] * 1e3 + hrTime[1] / 1e6;
+  return new Date(ms).toISOString();
+}
+function hrTimeToNanos(hrTime) {
+  return hrTime[0] * 1e9 + hrTime[1];
+}
+function durationNanos(start, end) {
+  return hrTimeToNanos(end) - hrTimeToNanos(start);
+}
+function flattenKey(key) {
+  return key.replace(/\./g, "@");
+}
+function spanKindToString(kind) {
+  switch (kind) {
+    case SpanKind.INTERNAL:
+      return "SPAN_KIND_INTERNAL";
+    case SpanKind.SERVER:
+      return "SPAN_KIND_SERVER";
+    case SpanKind.CLIENT:
+      return "SPAN_KIND_CLIENT";
+    case SpanKind.PRODUCER:
+      return "SPAN_KIND_PRODUCER";
+    case SpanKind.CONSUMER:
+      return "SPAN_KIND_CONSUMER";
+    default:
+      return "SPAN_KIND_INTERNAL";
+  }
+}
+function statusCodeToInt(code) {
+  switch (code) {
+    case SpanStatusCode.UNSET:
+      return 0;
+    case SpanStatusCode.OK:
+      return 1;
+    case SpanStatusCode.ERROR:
+      return 2;
+    default:
+      return 0;
+  }
+}
+function spanToDocument(span) {
+  const doc = {
+    traceId: span.spanContext().traceId,
+    spanId: span.spanContext().spanId,
+    parentSpanId: span.parentSpanContext?.spanId && span.parentSpanContext.spanId !== "0000000000000000" ? span.parentSpanContext.spanId : "",
+    name: span.name,
+    kind: spanKindToString(span.kind),
+    startTime: hrTimeToDate(span.startTime),
+    endTime: hrTimeToDate(span.endTime),
+    durationInNanos: durationNanos(span.startTime, span.endTime),
+    "status.code": statusCodeToInt(span.status.code),
+    "status.message": span.status.message || "",
+    traceState: "",
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount
+  };
+  for (const [key, value] of Object.entries(span.attributes)) {
+    if (value !== void 0) {
+      doc[`span.attributes.${flattenKey(key)}`] = value;
+    }
+  }
+  const resource = span.resource;
+  if (resource?.attributes) {
+    for (const [key, value] of Object.entries(resource.attributes)) {
+      if (value !== void 0) {
+        doc[`resource.attributes.${flattenKey(key)}`] = value;
+      }
+    }
+  }
+  const serviceName = resource?.attributes?.["service.name"] || "unknown";
+  doc.serviceName = serviceName;
+  const scope = span.instrumentationScope ?? span.instrumentationLibrary ?? {};
+  doc["instrumentationScope.name"] = scope.name || "";
+  if (scope.version) {
+    doc["instrumentationScope.version"] = scope.version;
+  }
+  if (span.events.length > 0) {
+    doc.events = span.events.map((event) => {
+      const eventDoc = {
+        name: event.name,
+        time: hrTimeToDate(event.time),
+        droppedAttributesCount: event.droppedAttributesCount || 0
+      };
+      if (event.attributes) {
+        const attrs = {};
+        for (const [key, value] of Object.entries(event.attributes)) {
+          if (value !== void 0) {
+            attrs[flattenKey(key)] = value;
+          }
+        }
+        eventDoc.attributes = attrs;
+      }
+      return eventDoc;
+    });
+  } else {
+    doc.events = [];
+  }
+  if (span.links.length > 0) {
+    doc.links = span.links.map((link) => ({
+      traceId: link.context.traceId,
+      spanId: link.context.spanId,
+      traceState: link.context.traceState?.serialize() || "",
+      attributes: link.attributes || {},
+      droppedAttributesCount: link.droppedAttributesCount || 0
+    }));
+  } else {
+    doc.links = [];
+  }
+  const hasRealParent = span.parentSpanContext?.spanId && span.parentSpanContext.spanId !== "0000000000000000";
+  if (!hasRealParent) {
+    doc.traceGroup = span.name;
+    doc.traceGroupFields = {
+      endTime: hrTimeToDate(span.endTime),
+      durationInNanos: durationNanos(span.startTime, span.endTime),
+      statusCode: statusCodeToInt(span.status.code)
+    };
+  }
+  return doc;
+}
+var OpenSearchSpanExporter = class {
+  constructor(config2) {
+    this.shutdownRequested = false;
+    const auth = config2.username && config2.password ? `${config2.username}:${config2.password}` : void 0;
+    this.client = new Client2({
+      node: config2.endpoint,
+      auth: auth ? { username: config2.username, password: config2.password } : void 0,
+      ssl: {
+        rejectUnauthorized: config2.tlsSkipVerify !== true
+      }
+    });
+    this.indexName = config2.indexName || "otel-v1-apm-span-000001";
+    console.log(`[Telemetry] OpenSearch exporter initialized \u2192 ${config2.endpoint} (index: ${this.indexName})`);
+  }
+  export(spans, resultCallback) {
+    if (this.shutdownRequested) {
+      resultCallback({ code: ExportResultCode.FAILED });
+      return;
+    }
+    this._export(spans).then(() => resultCallback({ code: ExportResultCode.SUCCESS })).catch((err) => {
+      console.error("[Telemetry] OpenSearch export failed:", err instanceof Error ? err.message : err);
+      resultCallback({ code: ExportResultCode.FAILED });
+    });
+  }
+  async _export(spans) {
+    if (spans.length === 0) return;
+    const body = [];
+    for (const span of spans) {
+      const doc = spanToDocument(span);
+      const docId = `${doc.traceId}/${doc.spanId}`;
+      body.push({ index: { _index: this.indexName, _id: docId } });
+      body.push(doc);
+    }
+    const response = await this.client.bulk({ body });
+    if (response.body.errors) {
+      const errors = response.body.items.filter((item) => item.index?.error).map((item) => `${item.index.error.type}: ${item.index.error.reason}`);
+      if (errors.length > 0) {
+        console.warn(`[Telemetry] OpenSearch bulk write had ${errors.length} error(s):`, errors[0]);
+      }
+    } else {
+      console.log(`[Telemetry] Exported ${spans.length} span(s) to OpenSearch`);
+    }
+  }
+  async shutdown() {
+    this.shutdownRequested = true;
+    await this.client.close();
+  }
+  async forceFlush() {
+  }
+};
+
+// lib/telemetry/provider.ts
+var provider = null;
+var telemetryEnabled = false;
+function resolveEvalTelemetryConfig(userConfig) {
+  const enabled = userConfig?.enabled ?? process.env.OTEL_EVAL_ENABLED === "true";
+  const exporterEndpoint = userConfig?.exporterEndpoint ?? process.env.OTEL_EVAL_EXPORTER_ENDPOINT ?? "http://localhost:4318/v1/traces";
+  let exporterHeaders = userConfig?.exporterHeaders;
+  if (!exporterHeaders && process.env.OTEL_EVAL_EXPORTER_HEADERS) {
+    try {
+      exporterHeaders = JSON.parse(process.env.OTEL_EVAL_EXPORTER_HEADERS);
+    } catch {
+      console.warn("[Telemetry] Failed to parse OTEL_EVAL_EXPORTER_HEADERS as JSON");
+    }
+  }
+  const serviceName = userConfig?.serviceName ?? process.env.OTEL_EVAL_SERVICE_NAME ?? "agent-health";
+  return { enabled, exporterEndpoint, exporterHeaders, serviceName, opensearch: userConfig?.opensearch };
+}
+function initEvalTracerProvider(config2) {
+  if (provider) {
+    return;
+  }
+  if (!config2.enabled) {
+    telemetryEnabled = false;
+    console.log("[Telemetry] Evaluation telemetry disabled (OTEL_EVAL_ENABLED != true)");
+    return;
+  }
+  const resource = resourceFromAttributes({
+    "service.name": config2.serviceName ?? "agent-health",
+    "telemetry.sdk.name": "agent-health",
+    "telemetry.sdk.language": "nodejs"
+  });
+  const spanProcessors = [];
+  const hasExplicitOtlpEndpoint = config2.exporterEndpoint !== "http://localhost:4318/v1/traces";
+  if (hasExplicitOtlpEndpoint) {
+    const otlpExporter = new OTLPTraceExporter({
+      url: config2.exporterEndpoint,
+      headers: config2.exporterHeaders
+    });
+    spanProcessors.push(new BatchSpanProcessor(otlpExporter));
+    console.log(`[Telemetry] Evaluation telemetry enabled \u2192 OTLP (${config2.exporterEndpoint})`);
+  } else if (config2.opensearch) {
+    const osExporter = new OpenSearchSpanExporter(config2.opensearch);
+    spanProcessors.push(new SimpleSpanProcessor(osExporter));
+    console.log(`[Telemetry] Evaluation telemetry enabled \u2192 OpenSearch direct (${config2.opensearch.endpoint})`);
+  } else {
+    const otlpExporter = new OTLPTraceExporter({
+      url: config2.exporterEndpoint,
+      headers: config2.exporterHeaders
+    });
+    spanProcessors.push(new BatchSpanProcessor(otlpExporter));
+    console.log(`[Telemetry] Evaluation telemetry enabled \u2192 OTLP (${config2.exporterEndpoint})`);
+  }
+  provider = new NodeTracerProvider({
+    resource,
+    spanProcessors
+  });
+  provider.register();
+  telemetryEnabled = true;
+}
+function getEvalTracer() {
+  return trace.getTracer(EVAL_TRACER_NAME);
+}
+function isEvalTelemetryEnabled() {
+  return telemetryEnabled;
+}
+async function flushEvalTracer() {
+  if (provider) {
+    try {
+      await provider.forceFlush();
+    } catch (err) {
+      console.warn("[Telemetry] forceFlush failed:", err instanceof Error ? err.message : err);
+    }
+  }
+}
+async function shutdownEvalTracer() {
+  if (provider) {
+    await provider.shutdown();
+    provider = null;
+    telemetryEnabled = false;
+    console.log("[Telemetry] Evaluation telemetry shut down");
+  }
+}
+
+// lib/telemetry/evalSpans.ts
+import {
+  context,
+  trace as trace2,
+  TraceFlags,
+  SpanKind as SpanKind2,
+  SpanStatusCode as SpanStatusCode2
+} from "@opentelemetry/api";
+function truncate(value, maxLength) {
+  if (!value) return void 0;
+  return value.length > maxLength ? value.slice(0, maxLength) + "..." : value;
+}
+function extractAgentResponse(report) {
+  const responseStep = [...report.trajectory].reverse().find(
+    (s) => s.type === "response" || s.type === "assistant"
+  );
+  return responseStep?.content;
+}
+function startTestSuiteRunSpan(benchmark, run) {
+  if (!isEvalTelemetryEnabled()) return null;
+  const tracer = getEvalTracer();
+  const span = tracer.startSpan(`test_suite_run ${benchmark.name}`, {
+    kind: SpanKind2.INTERNAL,
+    attributes: {
+      [ATTR_TEST_SUITE_NAME]: benchmark.name,
+      [ATTR_TEST_SUITE_RUN_ID]: run.id,
+      [ATTR_GEN_AI_OPERATION_NAME4]: GEN_AI_OPERATION_NAME_VALUE_EVALUATION
+    }
+  });
+  const ctx = context.active();
+  const spanContext = trace2.setSpan(ctx, span);
+  console.log(`[Telemetry] Started test_suite_run span for "${benchmark.name}" (runId=${run.id})`);
+  return { span, context: spanContext };
+}
+function startTestCaseSpan(parentCtx, testCase, benchmark, run, agentRunId, links) {
+  if (!isEvalTelemetryEnabled()) return null;
+  const tracer = getEvalTracer();
+  const attributes = {
+    [ATTR_TEST_SUITE_NAME]: benchmark.name,
+    [ATTR_TEST_SUITE_RUN_ID]: run.id,
+    [ATTR_TEST_CASE_ID]: testCase.id,
+    [ATTR_TEST_CASE_NAME]: testCase.name,
+    [ATTR_GEN_AI_OPERATION_NAME4]: GEN_AI_OPERATION_NAME_VALUE_EVALUATION
+  };
+  if (agentRunId) {
+    attributes[ATTR_AGENT_HEALTH_AGENT_RUN_ID] = agentRunId;
+  }
+  attributes[ATTR_TEST_CASE_INPUT] = truncate(testCase.initialPrompt || "", MAX_ATTRIBUTE_LENGTH);
+  const expected = truncate(
+    testCase.expectedOutcomes ? JSON.stringify(testCase.expectedOutcomes) : void 0,
+    MAX_ATTRIBUTE_LENGTH
+  );
+  if (expected) attributes[ATTR_TEST_CASE_EXPECTED] = expected;
+  const span = tracer.startSpan(
+    "test_case",
+    {
+      kind: SpanKind2.INTERNAL,
+      attributes,
+      links
+    },
+    parentCtx
+  );
+  const ctx = trace2.setSpan(parentCtx, span);
+  console.log(`[Telemetry] Started test_case span for "${testCase.name}" (agentRunId=${agentRunId || "none"})`);
+  return { span, context: ctx };
+}
+function addEvaluationResultEvents(span, report) {
+  if (!isEvalTelemetryEnabled()) return;
+  if (report.metrics?.accuracy !== void 0) {
+    span.addEvent(EVENT_GEN_AI_EVALUATION_RESULT, {
+      [ATTR_GEN_AI_EVALUATION_NAME]: "accuracy",
+      [ATTR_GEN_AI_EVALUATION_SCORE_VALUE]: report.metrics.accuracy,
+      [ATTR_GEN_AI_EVALUATION_SCORE_LABEL]: report.passFailStatus === "passed" ? "pass" : "fail",
+      [ATTR_GEN_AI_EVALUATION_EXPLANATION]: truncate(report.llmJudgeReasoning, MAX_EXPLANATION_LENGTH)
+    });
+  }
+  if (report.metrics?.faithfulness !== void 0) {
+    span.addEvent(EVENT_GEN_AI_EVALUATION_RESULT, {
+      [ATTR_GEN_AI_EVALUATION_NAME]: "faithfulness",
+      [ATTR_GEN_AI_EVALUATION_SCORE_VALUE]: report.metrics.faithfulness
+    });
+  }
+  if (report.metrics?.latency_score !== void 0) {
+    span.addEvent(EVENT_GEN_AI_EVALUATION_RESULT, {
+      [ATTR_GEN_AI_EVALUATION_NAME]: "latency_score",
+      [ATTR_GEN_AI_EVALUATION_SCORE_VALUE]: report.metrics.latency_score
+    });
+  }
+  if (report.metrics?.trajectory_alignment_score !== void 0) {
+    span.addEvent(EVENT_GEN_AI_EVALUATION_RESULT, {
+      [ATTR_GEN_AI_EVALUATION_NAME]: "trajectory_alignment_score",
+      [ATTR_GEN_AI_EVALUATION_SCORE_VALUE]: report.metrics.trajectory_alignment_score
+    });
+  }
+}
+function finalizeTestCaseSpan(span, report, endTime) {
+  if (!isEvalTelemetryEnabled()) return;
+  const status = report.passFailStatus === "passed" ? TEST_CASE_RESULT_STATUS_VALUE_PASS : TEST_CASE_RESULT_STATUS_VALUE_FAIL;
+  span.setAttribute(ATTR_TEST_CASE_RESULT_STATUS, status);
+  const output = extractAgentResponse(report) || "";
+  span.setAttribute(ATTR_TEST_CASE_OUTPUT, truncate(output, MAX_ATTRIBUTE_LENGTH));
+  if (report.connectorProtocol) {
+    span.setAttribute(ATTR_AGENT_HEALTH_CONNECTOR_PROTOCOL, report.connectorProtocol);
+  }
+  if (report.performanceMetrics?.agentDurationMs !== void 0) {
+    span.setAttribute(ATTR_AGENT_HEALTH_AGENT_DURATION_MS, report.performanceMetrics.agentDurationMs);
+  }
+  if (report.performanceMetrics?.judgeDurationMs !== void 0) {
+    span.setAttribute(ATTR_AGENT_HEALTH_JUDGE_DURATION_MS, report.performanceMetrics.judgeDurationMs);
+  }
+  if (report.performanceMetrics?.judgeAttempts !== void 0) {
+    span.setAttribute(ATTR_AGENT_HEALTH_JUDGE_ATTEMPTS, report.performanceMetrics.judgeAttempts);
+  }
+  if (report.llmJudgeResponse?.modelId) {
+    span.setAttribute(ATTR_AGENT_HEALTH_JUDGE_MODEL_ID, report.llmJudgeResponse.modelId);
+  }
+  if (report.status === "failed") {
+    span.setStatus({ code: SpanStatusCode2.ERROR, message: "Evaluation failed" });
+  }
+  span.end(endTime);
+  console.log(`[Telemetry] Finalized test_case span (status=${status}, passFailStatus=${report.passFailStatus})`);
+}
+function finalizeTestSuiteRunSpan(span, run) {
+  if (!isEvalTelemetryEnabled()) return;
+  const results = Object.values(run.results);
+  const hasFailures = results.some((r) => r.status === "failed");
+  const status = hasFailures ? TEST_SUITE_RUN_STATUS_VALUE_FAILURE : TEST_SUITE_RUN_STATUS_VALUE_SUCCESS;
+  span.setAttribute(ATTR_TEST_SUITE_RUN_STATUS, status);
+  if (hasFailures) {
+    const failCount = results.filter((r) => r.status === "failed").length;
+    span.setStatus({ code: SpanStatusCode2.ERROR, message: `${failCount} case(s) failed` });
+  }
+  span.end();
+  console.log(`[Telemetry] Finalized test_suite_run span (status=${status}), flushing...`);
+  flushEvalTracer().catch(() => {
+  });
+}
+function emitDeferredTestCaseSpan(testCase, report, benchmark, runId, agentRunId, startTime, endTime, agentTraceId) {
+  if (!isEvalTelemetryEnabled()) return;
+  const tracer = getEvalTracer();
+  const attributes = {
+    [ATTR_TEST_SUITE_NAME]: benchmark.name,
+    [ATTR_TEST_SUITE_RUN_ID]: runId,
+    [ATTR_TEST_CASE_ID]: testCase.id,
+    [ATTR_TEST_CASE_NAME]: testCase.name,
+    [ATTR_GEN_AI_OPERATION_NAME4]: GEN_AI_OPERATION_NAME_VALUE_EVALUATION
+  };
+  if (agentRunId) {
+    attributes[ATTR_AGENT_HEALTH_AGENT_RUN_ID] = agentRunId;
+  }
+  attributes[ATTR_TEST_CASE_INPUT] = truncate(testCase.initialPrompt || "", MAX_ATTRIBUTE_LENGTH);
+  const expected = truncate(
+    testCase.expectedOutcomes ? JSON.stringify(testCase.expectedOutcomes) : void 0,
+    MAX_ATTRIBUTE_LENGTH
+  );
+  if (expected) attributes[ATTR_TEST_CASE_EXPECTED] = expected;
+  let parentCtx;
+  if (agentTraceId) {
+    const remoteSpanContext = {
+      traceId: agentTraceId,
+      // Use a valid synthetic spanId — an all-zero spanId is considered invalid
+      // by the OTel SDK and would cause it to ignore this context entirely.
+      // This "remote" context carries the traceId forward so the eval span
+      // shares the same trace as the agent spans.
+      spanId: "eeee000000000001",
+      traceFlags: TraceFlags.SAMPLED,
+      isRemote: true
+    };
+    parentCtx = trace2.setSpanContext(context.active(), remoteSpanContext);
+  }
+  const span = tracer.startSpan("test_case", {
+    kind: SpanKind2.INTERNAL,
+    startTime,
+    attributes
+  }, parentCtx);
+  addEvaluationResultEvents(span, report);
+  finalizeTestCaseSpan(span, report, endTime);
+  console.log(`[Telemetry] Emitted deferred test_case span for "${testCase.name}" (agentRunId=${agentRunId || "none"}, traceId=${agentTraceId || "new"}), flushing...`);
+  flushEvalTracer().catch(() => {
+  });
+}
+
 // services/benchmarkRunner.ts
+import { SpanStatusCode as SpanStatusCode3 } from "@opentelemetry/api";
 function getConfig() {
   try {
     return loadConfigSync();
@@ -13374,6 +14458,9 @@ async function executeRun(benchmark, run, onProgress, options) {
   const concurrency = run.concurrency ?? 1;
   const runStartTime = Date.now();
   console.log(`[BenchmarkRunner] Starting run ${run.id} with concurrency=${concurrency} for ${totalTestCases} test cases`);
+  const suiteSpanResult = startTestSuiteRunSpan(benchmark, run);
+  const suiteSpan = suiteSpanResult?.span;
+  const suiteContext = suiteSpanResult?.context;
   if (!run.results) {
     run.results = {};
   }
@@ -13424,6 +14511,7 @@ async function executeRun(benchmark, run, onProgress, options) {
         });
         debug("BenchmarkRunner", `[${testCaseId}] Starting evaluation (${completedCount}/${totalTestCases} completed)`);
         const testCaseStartTime = Date.now();
+        let caseSpan;
         run.results[testCaseId] = { reportId: "", status: "running" };
         try {
           const agentConfig = buildAgentConfigForRun(run);
@@ -13443,7 +14531,23 @@ async function executeRun(benchmark, run, onProgress, options) {
           });
           updateTestCaseLastRunAt(client, testCaseId, (/* @__PURE__ */ new Date()).toISOString()).catch((err) => console.warn(`[BenchmarkRunner] Failed to update lastRunAt for ${testCaseId}:`, err.message));
           if (savedReport.metricsStatus === "pending" && savedReport.runId) {
-            startTracePollingForReport(savedReport, testCase, client);
+            startTracePollingForReport(savedReport, testCase, client, benchmark, run);
+          }
+          if (suiteContext) {
+            const caseSpanResult = startTestCaseSpan(
+              suiteContext,
+              testCase,
+              benchmark,
+              run,
+              savedReport.runId
+            );
+            caseSpan = caseSpanResult?.span;
+            if (caseSpan && savedReport.metricsStatus !== "pending") {
+              addEvaluationResultEvents(caseSpan, savedReport);
+              finalizeTestCaseSpan(caseSpan, savedReport);
+            } else if (caseSpan) {
+              caseSpan.end();
+            }
           }
           run.results[testCaseId] = {
             reportId: savedReport.id,
@@ -13462,6 +14566,10 @@ async function executeRun(benchmark, run, onProgress, options) {
           const testCaseDuration = Date.now() - testCaseStartTime;
           debug("BenchmarkRunner", `[${testCaseId}] Failed in ${testCaseDuration}ms: ${errorMsg}`);
           run.results[testCaseId] = { reportId: "", status: "failed", error: errorMsg };
+          if (caseSpan) {
+            caseSpan.setStatus({ code: SpanStatusCode3.ERROR, message: errorMsg });
+            caseSpan.end();
+          }
           completedCount++;
           if (errorMsg.includes("ThrottlingException") || errorMsg.includes("rate limit") || errorMsg.includes("429")) {
             consecutiveThrottles++;
@@ -13505,6 +14613,9 @@ async function executeRun(benchmark, run, onProgress, options) {
       maxTestCaseDurationMs: testCaseDurations.length > 0 ? Math.max(...testCaseDurations) : 0,
       minTestCaseDurationMs: testCaseDurations.length > 0 ? Math.min(...testCaseDurations) : 0
     };
+    if (suiteSpan) {
+      finalizeTestSuiteRunSpan(suiteSpan, run);
+    }
     return run;
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
@@ -13513,6 +14624,10 @@ async function executeRun(benchmark, run, onProgress, options) {
         run.results[testCaseId] = { reportId: "", status: "failed", error: `Benchmark execution failed: ${errorMsg}` };
       }
     });
+    if (suiteSpan) {
+      suiteSpan.setStatus({ code: SpanStatusCode3.ERROR, message: errorMsg });
+      suiteSpan.end();
+    }
     throw error;
   }
 }
@@ -13544,6 +14659,7 @@ async function saveReportWithModule(storage, report) {
 async function runSingleUseCase(run, testCase, storage, onStep) {
   const agentConfig = buildAgentConfigForRun(run);
   const bedrockModelId = getBedrockModelId(run.modelId);
+  const startTime = /* @__PURE__ */ new Date();
   const report = await runEvaluationWithConnector(
     agentConfig,
     bedrockModelId,
@@ -13561,6 +14677,17 @@ async function runSingleUseCase(run, testCase, storage, onStep) {
   if (savedReport.metricsStatus === "pending" && savedReport.runId) {
     startTracePollingForReportWithModule(savedReport, testCase, storage);
   }
+  if (savedReport.metricsStatus !== "pending") {
+    emitDeferredTestCaseSpan(
+      testCase,
+      savedReport,
+      { name: `standalone:${agentConfig.name || agentConfig.key}` },
+      run.id,
+      savedReport.runId,
+      startTime,
+      /* @__PURE__ */ new Date()
+    );
+  }
   return savedReport.id;
 }
 function startTracePollingForReportWithModule(report, testCase, storage) {
@@ -13600,6 +14727,24 @@ function startTracePollingForReportWithModule(report, testCase, storage) {
             llmJudgeReasoning: judgment.llmJudgeReasoning,
             improvementStrategies: judgment.improvementStrategies
           });
+          const completedReport = {
+            ...report,
+            passFailStatus: judgment.passFailStatus,
+            metrics: judgment.metrics,
+            llmJudgeReasoning: judgment.llmJudgeReasoning
+          };
+          emitDeferredTestCaseSpan(
+            testCase,
+            completedReport,
+            { name: report.experimentId ? `benchmark:${report.experimentId}` : `standalone:${report.agentKey}` },
+            report.experimentRunId || report.id,
+            report.runId,
+            void 0,
+            // startTime
+            void 0,
+            // endTime
+            spans[0]?.traceId
+          );
           if (report.experimentId) {
             await refreshBenchmarkRunStats(storage, report.experimentId, report.id);
           }
@@ -13627,7 +14772,7 @@ function startTracePollingForReportWithModule(report, testCase, storage) {
     }
   );
 }
-function startTracePollingForReport(report, testCase, client) {
+function startTracePollingForReport(report, testCase, client, benchmark, run) {
   if (!report.runId) {
     console.warn(`[BenchmarkRunner] No runId for report ${report.id}, cannot start trace polling`);
     return;
@@ -13662,6 +14807,16 @@ function startTracePollingForReport(report, testCase, client) {
           if (report.experimentId) {
             await updateBenchmarkRunStatsForReport(client, report.experimentId, report.id);
           }
+          if (benchmark && run) {
+            const completedReport = {
+              ...report,
+              passFailStatus: judgment.passFailStatus,
+              metrics: judgment.metrics,
+              llmJudgeReasoning: judgment.llmJudgeReasoning
+            };
+            const agentTraceId = spans[0]?.traceId;
+            emitDeferredTestCaseSpan(testCase, completedReport, benchmark, run.id, report.runId, void 0, void 0, agentTraceId);
+          }
         } catch (error) {
           console.error(`[BenchmarkRunner] Failed to judge report ${report.id}:`, error instanceof Error ? error.message : error);
           await updateRunWithClient(client, report.id, {
@@ -15097,11 +16252,13 @@ router10.get("/api/storage/runs", async (req, res) => {
   try {
     const { size = "100", from = "0", fields } = req.query;
     let realData = [];
+    const fieldList = typeof fields === "string" ? fields.split(",").map((f) => f.trim()).filter(Boolean) : void 0;
     const storage = getStorageModule();
     try {
       const result = await storage.runs.getAll({
         size: parseInt(size),
-        from: parseInt(from)
+        from: parseInt(from),
+        _source: fieldList
       });
       realData = result.items;
     } catch (e) {
@@ -19263,7 +20420,25 @@ async function initializeStorageBackend() {
 }
 async function createApp() {
   await migrateYamlToJsonIfNeeded();
-  await loadConfig();
+  const config2 = await loadConfig();
+  const obsConfig = getObservabilityConfigFromFile() ?? getObservabilityConfigFromEnv();
+  let opensearchExporterConfig;
+  if (obsConfig?.endpoint) {
+    opensearchExporterConfig = {
+      endpoint: obsConfig.endpoint,
+      username: obsConfig.username,
+      password: obsConfig.password,
+      tlsSkipVerify: obsConfig.tlsSkipVerify,
+      indexName: "otel-v1-apm-span"
+    };
+  }
+  initEvalTracerProvider(resolveEvalTelemetryConfig({
+    ...config2.telemetry,
+    opensearch: opensearchExporterConfig
+  }));
+  process.once("SIGTERM", async () => {
+    await shutdownEvalTracer();
+  });
   await initializeStorageBackend();
   const app = express2();
   setupMiddleware(app);