@opensearch-project/agent-health 0.0.1 → 0.1.0

package/lib/dist/index.js

@@ -0,0 +1,1527 @@
+// lib/config/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+
+// lib/debug.ts
+var isBrowser = typeof window !== "undefined";
+var serverDebugEnabled = !isBrowser && typeof process !== "undefined" && process.env?.DEBUG === "true";
+function isDebugEnabled() {
+  if (isBrowser) {
+    try {
+      return localStorage.getItem("agenteval_debug") === "true";
+    } catch {
+      return false;
+    }
+  }
+  return serverDebugEnabled;
+}
+function debug(module, ...args) {
+  if (isDebugEnabled()) {
+    console.debug(`[${module}]`, ...args);
+  }
+}
+
+// services/connectors/base/BaseConnector.ts
+var BaseConnector = class {
+  /**
+   * Build HTTP headers from auth configuration
+   * @param auth Authentication configuration
+   * @returns Headers object ready for fetch/axios
+   */
+  buildAuthHeaders(auth) {
+    const headers = {};
+    switch (auth.type) {
+      case "basic":
+        if (auth.username && auth.password) {
+          const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
+          headers["Authorization"] = `Basic ${credentials}`;
+        }
+        break;
+      case "bearer":
+        if (auth.token) {
+          headers["Authorization"] = `Bearer ${auth.token}`;
+        }
+        break;
+      case "api-key":
+        if (auth.token) {
+          headers["X-API-Key"] = auth.token;
+          headers["x-api-key"] = auth.token;
+        }
+        break;
+      case "aws-sigv4":
+        console.warn("[BaseConnector] AWS SigV4 auth requires runtime signing");
+        break;
+      case "none":
+      default:
+        break;
+    }
+    if (auth.headers) {
+      Object.assign(headers, auth.headers);
+    }
+    return headers;
+  }
+  /**
+   * Build environment variables from auth configuration
+   * Used by subprocess connectors
+   */
+  buildAuthEnv(auth) {
+    const env = {};
+    if (auth.type === "aws-sigv4") {
+      if (auth.awsRegion) env["AWS_REGION"] = auth.awsRegion;
+      if (auth.awsAccessKeyId) env["AWS_ACCESS_KEY_ID"] = auth.awsAccessKeyId;
+      if (auth.awsSecretAccessKey) env["AWS_SECRET_ACCESS_KEY"] = auth.awsSecretAccessKey;
+      if (auth.awsSessionToken) env["AWS_SESSION_TOKEN"] = auth.awsSessionToken;
+    }
+    return env;
+  }
+  /**
+   * Generate a unique ID for trajectory steps
+   */
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Create a trajectory step with common fields
+   */
+  createStep(type, content, extra) {
+    return {
+      id: this.generateId(),
+      timestamp: Date.now(),
+      type,
+      content,
+      ...extra
+    };
+  }
+  /**
+   * Default health check implementation
+   * Subclasses can override for protocol-specific checks
+   */
+  async healthCheck(endpoint, auth) {
+    try {
+      const headers = this.buildAuthHeaders(auth);
+      const response = await fetch(endpoint, {
+        method: "HEAD",
+        headers
+      });
+      return response.ok;
+    } catch (error) {
+      console.error(`[${this.type}] Health check failed:`, error);
+      return false;
+    }
+  }
+  /**
+   * Log debug message with connector type prefix
+   */
+  debug(message, ...args) {
+    debug(this.type, message, ...args);
+  }
+  /**
+   * Log error message with connector type prefix
+   */
+  error(message, ...args) {
+    console.error(`[${this.type}] ${message}`, ...args);
+  }
+};
+
+// types/agui.ts
+import { EventType } from "@ag-ui/core";
+var AGUIEventType = EventType;
+
+// services/agent/sseStream.ts
+var SSEClient = class {
+  constructor() {
+    this.abortController = null;
+  }
+  /**
+   * Start consuming SSE stream from the agent endpoint
+   */
+  async consume(options) {
+    const {
+      url,
+      method = "POST",
+      headers = {},
+      body,
+      onEvent,
+      onError,
+      onComplete,
+      completeOnRunEnd = false,
+      idleTimeoutMs = 12e4
+      // 2 minute idle timeout by default (LLM agents can be slow)
+    } = options;
+    this.abortController = new AbortController();
+    debug("SSE", "Connecting to", url);
+    debug("SSE", "Method:", method);
+    debug("SSE", "Payload:", JSON.stringify(body, null, 2).substring(0, 500));
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...headers
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body is null");
+      }
+      debug("SSE", "Connected, streaming events...");
+      debug("SSE", "Response status:", response.status);
+      debug("SSE", "Content-Type:", response.headers.get("content-type"));
+      const completionReason = await this.processStream(response.body, onEvent, completeOnRunEnd, idleTimeoutMs);
+      debug("SSE", `Stream completed: ${completionReason}`);
+      onComplete?.();
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          debug("SSE", "Stream aborted (expected after run completion)");
+          onComplete?.();
+        } else {
+          console.error("[SSE] Stream error:", error.message);
+          onError?.(error);
+        }
+      } else {
+        onError?.(new Error("Unknown error occurred"));
+      }
+    }
+  }
+  /**
+   * Process the ReadableStream and parse SSE events
+   * @returns Reason for stream completion
+   */
+  async processStream(stream, onEvent, completeOnRunEnd = false, idleTimeoutMs = 12e4) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let lastEventTime = Date.now();
+    let eventCount = 0;
+    let idleCheckInterval = null;
+    const idleTimeoutPromise = new Promise((resolve) => {
+      idleCheckInterval = setInterval(() => {
+        const idleTime = Date.now() - lastEventTime;
+        if (eventCount > 0 && idleTime > idleTimeoutMs) {
+          debug("SSE", `Idle timeout: no events for ${idleTime}ms (threshold: ${idleTimeoutMs}ms)`);
+          this.abort();
+          resolve("idle_timeout");
+        }
+      }, 1e3);
+    });
+    try {
+      const streamPromise = (async () => {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            return "connection_closed";
+          }
+          lastEventTime = Date.now();
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data.trim()) {
+                debug("SSE", "Raw event:", data.substring(0, 200) + (data.length > 200 ? "..." : ""));
+                try {
+                  const event = JSON.parse(data);
+                  debug("SSE", "Parsed:", event.type);
+                  eventCount++;
+                  onEvent(event);
+                  if (completeOnRunEnd && (event.type === AGUIEventType.RUN_FINISHED || event.type === AGUIEventType.RUN_ERROR)) {
+                    debug("SSE", `Received ${event.type}, completing stream`);
+                    this.abort();
+                    return `event:${event.type}`;
+                  }
+                } catch (parseError) {
+                  console.error("[SSE] Parse error:", parseError);
+                  debug("SSE", "Failed data:", data);
+                }
+              }
+            }
+          }
+        }
+      })();
+      const reason = await Promise.race([streamPromise, idleTimeoutPromise]);
+      return reason;
+    } finally {
+      if (idleCheckInterval) {
+        clearInterval(idleCheckInterval);
+      }
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Abort the current stream connection
+   */
+  abort() {
+    this.abortController?.abort();
+  }
+};
+async function consumeSSEStream(url, payload, onEvent, headers, options) {
+  const client = new SSEClient();
+  return new Promise((resolve, reject) => {
+    client.consume({
+      url,
+      method: "POST",
+      headers,
+      body: payload,
+      onEvent,
+      onError: (error) => reject(error),
+      onComplete: () => resolve(),
+      // Enable auto-completion on RUN_FINISHED/RUN_ERROR events
+      // This prevents hanging when the agent doesn't close the connection
+      completeOnRunEnd: true,
+      idleTimeoutMs: options?.idleTimeoutMs
+    });
+  });
+}
+
+// services/agent/payloadBuilder.ts
+var DEFAULT_PPL_TOOL = {
+  name: "execute_ppl_query",
+  description: "Update the query bar with a PPL query and optionally execute it",
+  parameters: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "The PPL query to set in the query bar"
+      },
+      autoExecute: {
+        type: "boolean",
+        description: "Whether to automatically execute the query (default: true)"
+      },
+      description: {
+        type: "string",
+        description: "Optional description of what the query does"
+      }
+    },
+    required: ["query"]
+  }
+};
+function generateId(prefix) {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}-${timestamp}-${random}`;
+}
+function buildAgentPayload(testCase, modelId, threadId, runId) {
+  const tools = testCase.tools || [DEFAULT_PPL_TOOL];
+  return {
+    threadId: threadId || generateId("thread"),
+    runId: runId || generateId("run"),
+    messages: [
+      {
+        id: generateId("msg"),
+        role: "user",
+        content: testCase.initialPrompt
+      }
+    ],
+    tools,
+    context: testCase.context || [],
+    state: {},
+    forwardedProps: {}
+  };
+}
+
+// services/agent/aguiConverter.ts
+import { v4 as uuidv4 } from "uuid";
+var AGUIToTrajectoryConverter = class {
+  constructor() {
+    this.currentTextMessage = null;
+    this.activeTools = /* @__PURE__ */ new Map();
+    this.hasEmittedAction = false;
+    this.runFinished = false;
+    this.pendingTextIsResponse = false;
+    this.runId = null;
+    this.threadId = null;
+    // Thinking state tracking
+    this.isThinking = false;
+    this.currentThinkingMessage = null;
+  }
+  /**
+   * Process a single AG UI event and convert it to TrajectoryStep(s)
+   * Returns an array of steps (usually 0 or 1, sometimes more)
+   */
+  processEvent(event) {
+    debug("Converter", `Event: ${event.type}`, JSON.stringify(event).substring(0, 300));
+    let steps = [];
+    switch (event.type) {
+      case AGUIEventType.RUN_STARTED:
+        steps = this.handleRunStarted(event);
+        break;
+      case AGUIEventType.RUN_FINISHED:
+        steps = this.handleRunFinished(event);
+        break;
+      case AGUIEventType.RUN_ERROR:
+        steps = this.handleRunError(event);
+        break;
+      case AGUIEventType.TEXT_MESSAGE_START:
+        steps = this.handleTextMessageStart(event);
+        break;
+      case AGUIEventType.TEXT_MESSAGE_CONTENT:
+        steps = this.handleTextMessageContent(event);
+        break;
+      case AGUIEventType.TEXT_MESSAGE_END:
+        steps = this.handleTextMessageEnd(event);
+        break;
+      case AGUIEventType.ACTIVITY_SNAPSHOT:
+        steps = this.handleActivitySnapshot(event);
+        break;
+      case AGUIEventType.ACTIVITY_DELTA:
+        steps = this.handleActivityDelta(event);
+        break;
+      case AGUIEventType.TOOL_CALL_START:
+        steps = this.handleToolCallStart(event);
+        break;
+      case AGUIEventType.TOOL_CALL_ARGS:
+        steps = this.handleToolCallArgs(event);
+        break;
+      case AGUIEventType.TOOL_CALL_END:
+        steps = this.handleToolCallEnd(event);
+        break;
+      case AGUIEventType.TOOL_CALL_RESULT:
+        steps = this.handleToolCallResult(event);
+        break;
+      // Thinking events - extended reasoning from the model
+      case AGUIEventType.THINKING_START:
+        steps = this.handleThinkingStart(event);
+        break;
+      case AGUIEventType.THINKING_END:
+        steps = this.handleThinkingEnd(event);
+        break;
+      case AGUIEventType.THINKING_TEXT_MESSAGE_START:
+        steps = this.handleThinkingTextMessageStart(event);
+        break;
+      case AGUIEventType.THINKING_TEXT_MESSAGE_CONTENT:
+        steps = this.handleThinkingTextMessageContent(event);
+        break;
+      case AGUIEventType.THINKING_TEXT_MESSAGE_END:
+        steps = this.handleThinkingTextMessageEnd(event);
+        break;
+      default:
+        debug("Converter", `Skipped unhandled event: ${event.type}`);
+        break;
+    }
+    if (steps.length > 0) {
+      debug("Converter", `Generated ${steps.length} step(s):`, steps.map((s) => `${s.type}${s.toolName ? `:${s.toolName}` : ""}`).join(", "));
+    }
+    return steps;
+  }
+  handleRunStarted(event) {
+    this.runId = event.runId;
+    this.threadId = event.threadId;
+    debug("Converter", `Run started - runId: ${this.runId}, threadId: ${this.threadId}`);
+    this.currentTextMessage = null;
+    this.activeTools.clear();
+    this.hasEmittedAction = false;
+    this.runFinished = false;
+    this.pendingTextIsResponse = false;
+    this.isThinking = false;
+    this.currentThinkingMessage = null;
+    return [];
+  }
+  getRunId() {
+    return this.runId;
+  }
+  getThreadId() {
+    return this.threadId;
+  }
+  handleRunFinished(event) {
+    this.runFinished = true;
+    if (this.currentTextMessage) {
+      this.pendingTextIsResponse = true;
+    }
+    return [];
+  }
+  handleRunError(event) {
+    console.error("[Converter] Run error:", event.message);
+    return [{
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: "tool_result",
+      content: `Error: ${event.message}`,
+      status: "FAILURE" /* FAILURE */
+    }];
+  }
+  handleTextMessageStart(event) {
+    debug("Converter", `Text message start: ${event.messageId}`);
+    this.currentTextMessage = {
+      messageId: event.messageId,
+      startTime: event.timestamp,
+      content: ""
+    };
+    return [];
+  }
+  handleTextMessageContent(event) {
+    if (this.currentTextMessage && this.currentTextMessage.messageId === event.messageId) {
+      this.currentTextMessage.content += event.delta;
+    }
+    return [];
+  }
+  handleTextMessageEnd(event) {
+    if (!this.currentTextMessage || this.currentTextMessage.messageId !== event.messageId) {
+      debug("Converter", `Text end for unknown message: ${event.messageId}`);
+      return [];
+    }
+    const latencyMs = event.timestamp - this.currentTextMessage.startTime;
+    const content = this.currentTextMessage.content.trim();
+    let stepType;
+    if (this.pendingTextIsResponse || this.runFinished) {
+      stepType = "response";
+    } else {
+      stepType = "assistant";
+    }
+    debug("Converter", `Classification: ${stepType} (runFinished=${this.runFinished}, pendingResponse=${this.pendingTextIsResponse}, hasAction=${this.hasEmittedAction})`);
+    if (stepType === "assistant" && content.length === 0) {
+      debug("Converter", "Skipping empty assistant message");
+      this.currentTextMessage = null;
+      return [];
+    }
+    const step = {
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: stepType,
+      content,
+      latencyMs
+    };
+    this.currentTextMessage = null;
+    return [step];
+  }
+  handleActivitySnapshot(event) {
+    const toolName = this.extractToolName(event.content.title);
+    const toolArgs = this.parseToolArgs(event.content.description);
+    const actionStepId = uuidv4();
+    this.activeTools.set(event.messageId, {
+      messageId: event.messageId,
+      toolName,
+      toolArgs,
+      argsAccumulator: "",
+      startTime: event.timestamp,
+      actionStepId
+    });
+    this.hasEmittedAction = true;
+    debug("Converter", `Tool action: ${toolName}`, toolArgs);
+    return [{
+      id: actionStepId,
+      timestamp: event.timestamp,
+      type: "action",
+      content: `Calling ${toolName}...`,
+      toolName,
+      toolArgs
+    }];
+  }
+  handleActivityDelta(event) {
+    const toolState = this.activeTools.get(event.messageId);
+    if (!toolState) return [];
+    const isCompletion = event.patch.some(
+      (op) => op.path === "/icon" && (op.value === "CheckCircle" || op.value === "Check")
+    );
+    if (!isCompletion) return [];
+    const descriptionPatch = event.patch.find((op) => op.path === "/description");
+    const resultContent = descriptionPatch?.value || "Tool execution completed";
+    const latencyMs = event.timestamp - toolState.startTime;
+    this.activeTools.delete(event.messageId);
+    return [{
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: "tool_result",
+      content: resultContent,
+      status: "SUCCESS" /* SUCCESS */,
+      latencyMs
+    }];
+  }
+  handleToolCallStart(event) {
+    const actionStepId = uuidv4();
+    this.activeTools.set(event.toolCallId, {
+      messageId: event.toolCallId,
+      toolName: event.toolCallName,
+      toolArgs: {},
+      argsAccumulator: "",
+      // Will accumulate delta strings
+      startTime: event.timestamp,
+      actionStepId
+    });
+    this.hasEmittedAction = true;
+    debug("Converter", `Tool call started: ${event.toolCallName} (${event.toolCallId})`);
+    return [];
+  }
+  handleToolCallArgs(event) {
+    const toolState = this.activeTools.get(event.toolCallId);
+    if (toolState) {
+      toolState.argsAccumulator += event.delta;
+      debug("Converter", `Tool args delta accumulated (${toolState.argsAccumulator.length} chars total)`);
+    }
+    return [];
+  }
+  /**
+   * Handle TOOL_CALL_END - emits the action step with complete args
+   * This is called when the agent is done sending tool call arguments
+   * and expects the client to execute the tool
+   */
+  handleToolCallEnd(event) {
+    const toolState = this.activeTools.get(event.toolCallId);
+    if (!toolState) {
+      debug("Converter", `Tool call end for unknown tool: ${event.toolCallId}`);
+      return [];
+    }
+    let parsedArgs = {};
+    if (toolState.argsAccumulator) {
+      try {
+        parsedArgs = JSON.parse(toolState.argsAccumulator);
+        debug("Converter", `Tool args parsed: ${JSON.stringify(parsedArgs).substring(0, 200)}`);
+      } catch {
+        parsedArgs = { _raw: toolState.argsAccumulator };
+      }
+    }
+    toolState.toolArgs = parsedArgs;
+    const latencyMs = event.timestamp - toolState.startTime;
+    const actionStep = {
+      id: toolState.actionStepId,
+      timestamp: toolState.startTime,
+      type: "action",
+      content: `Calling ${toolState.toolName}...`,
+      toolName: toolState.toolName,
+      toolArgs: parsedArgs,
+      latencyMs
+    };
+    debug("Converter", `Tool call end: ${toolState.toolName} - action step emitted with args`);
+    toolState.actionStepId = "";
+    return [actionStep];
+  }
+  handleToolCallResult(event) {
+    const toolState = this.activeTools.get(event.toolCallId);
+    if (!toolState) return [];
+    const latencyMs = event.timestamp - toolState.startTime;
+    const steps = [];
+    const actionAlreadyEmitted = !toolState.actionStepId;
+    if (!actionAlreadyEmitted) {
+      let parsedArgs = {};
+      if (toolState.argsAccumulator) {
+        try {
+          parsedArgs = JSON.parse(toolState.argsAccumulator);
+          debug("Converter", `Tool args parsed: ${JSON.stringify(parsedArgs).substring(0, 200)}`);
+        } catch {
+          parsedArgs = { _raw: toolState.argsAccumulator };
+        }
+      }
+      toolState.toolArgs = parsedArgs;
+      steps.push({
+        id: toolState.actionStepId,
+        timestamp: toolState.startTime,
+        type: "action",
+        content: `Calling ${toolState.toolName}...`,
+        toolName: toolState.toolName,
+        toolArgs: parsedArgs
+      });
+    }
+    let resultContent;
+    try {
+      const parsed = JSON.parse(event.content);
+      resultContent = typeof parsed === "string" ? parsed : JSON.stringify(parsed, null, 2);
+    } catch (e) {
+      resultContent = event.content;
+    }
+    steps.push({
+      id: uuidv4(),
+      timestamp: event.timestamp,
+      type: "tool_result",
+      content: resultContent,
+      status: "SUCCESS" /* SUCCESS */,
+      latencyMs
+    });
+    this.activeTools.delete(event.toolCallId);
+    debug("Converter", `Tool call result: ${toolState.toolName} -> ${steps.length} steps emitted (action already emitted: ${actionAlreadyEmitted})`);
+    return steps;
+  }
+  // ============ THINKING Event Handlers ============
+  handleThinkingStart(event) {
+    this.isThinking = true;
+    debug("Converter", "Thinking started");
+    return [];
+  }
+  handleThinkingEnd(event) {
+    this.isThinking = false;
+    debug("Converter", "Thinking ended");
+    return [];
+  }
+  handleThinkingTextMessageStart(event) {
+    this.currentThinkingMessage = {
+      startTime: event.timestamp || Date.now(),
+      content: ""
+    };
+    debug("Converter", "Thinking text message started");
+    return [];
+  }
+  handleThinkingTextMessageContent(event) {
+    if (this.currentThinkingMessage) {
+      this.currentThinkingMessage.content += event.delta;
+    }
+    return [];
+  }
+  handleThinkingTextMessageEnd(event) {
+    if (!this.currentThinkingMessage) {
+      debug("Converter", "Thinking text end with no active thinking message");
+      return [];
+    }
+    const content = this.currentThinkingMessage.content.trim();
+    if (content.length === 0) {
+      debug("Converter", "Skipping empty thinking message");
+      this.currentThinkingMessage = null;
+      return [];
+    }
+    const latencyMs = (event.timestamp || Date.now()) - this.currentThinkingMessage.startTime;
+    const step = {
+      id: uuidv4(),
+      timestamp: this.currentThinkingMessage.startTime,
+      type: "thinking",
+      content,
+      latencyMs
+    };
+    debug("Converter", `Thinking message completed: ${content.length} chars`);
+    this.currentThinkingMessage = null;
+    return [step];
+  }
+  extractToolName(title) {
+    const runningMatch = title.match(/^Running\s+(.+)$/);
+    if (runningMatch) return runningMatch[1];
+    const completedMatch = title.match(/^(.+)\s+completed$/i);
+    if (completedMatch) return completedMatch[1];
+    return title;
+  }
+  parseToolArgs(description) {
+    try {
+      const args = {};
+      const pairs = description.match(/(\w+):\s*("(?:[^"]|\\")*"|\w+)/g);
+      if (pairs) {
+        pairs.forEach((pair) => {
+          const [key, rawValue] = pair.split(":").map((s) => s.trim());
+          let value = rawValue;
+          if (rawValue.startsWith('"') && rawValue.endsWith('"')) {
+            value = rawValue.slice(1, -1);
+          } else if (rawValue === "true") {
+            value = true;
+          } else if (rawValue === "false") {
+            value = false;
+          } else if (!isNaN(Number(rawValue))) {
+            value = Number(rawValue);
+          }
+          args[key] = value;
+        });
+        return args;
+      }
+      return { description };
+    } catch (e) {
+      return { description };
+    }
+  }
+};
+function computeTrajectoryFromRawEvents(rawEvents) {
+  const converter = new AGUIToTrajectoryConverter();
+  const trajectory = [];
+  for (const event of rawEvents) {
+    const steps = converter.processEvent(event);
+    trajectory.push(...steps);
+  }
+  trajectory.sort((a, b) => a.timestamp - b.timestamp);
+  return trajectory;
+}
+
+// services/connectors/agui/AGUIStreamingConnector.ts
+var AGUIStreamingConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "agui-streaming";
+    this.name = "AG-UI Streaming";
+    this.supportsStreaming = true;
+  }
+  /**
+   * Build AG-UI payload from standard request
+   */
+  buildPayload(request) {
+    return buildAgentPayload(
+      request.testCase,
+      request.modelId,
+      request.threadId,
+      request.runId
+    );
+  }
+  /**
+   * Execute the request using SSE streaming
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    const hasPrebuiltPayload = !!request.payload;
+    const payload = request.payload || this.buildPayload(request);
+    const headers = this.buildAuthHeaders(auth);
+    const trajectory = [];
+    const rawEvents = [];
+    const converter = new AGUIToTrajectoryConverter();
+    this.debug("Executing AG-UI streaming request");
+    await consumeSSEStream(
+      endpoint,
+      payload,
+      (event) => {
+        rawEvents.push(event);
+        onRawEvent?.(event);
+        const steps = converter.processEvent(event);
+        steps.forEach((step) => {
+          trajectory.push(step);
+          onProgress?.(step);
+        });
+      },
+      headers
+    );
+    const runId = converter.getRunId();
+    this.debug("Stream completed. RunId:", runId, "Steps:", trajectory.length);
+    return {
+      trajectory,
+      runId,
+      rawEvents,
+      metadata: {
+        threadId: converter.getThreadId()
+      }
+    };
+  }
+  /**
+   * Parse raw AG-UI events into trajectory steps
+   * Used for re-processing stored raw events
+   */
+  parseResponse(rawEvents) {
+    return computeTrajectoryFromRawEvents(rawEvents);
+  }
+  /**
+   * Health check for AG-UI endpoint
+   * Tries to connect without sending a full request
+   */
+  async healthCheck(endpoint, auth) {
+    try {
+      const headers = this.buildAuthHeaders(auth);
+      const response = await fetch(endpoint, {
+        method: "OPTIONS",
+        headers
+      });
+      return true;
+    } catch (error) {
+      this.error("Health check failed:", error);
+      return false;
+    }
+  }
+};
+var aguiStreamingConnector = new AGUIStreamingConnector();
+
+// services/connectors/rest/RESTConnector.ts
+var RESTConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "rest";
+    this.name = "REST API";
+    this.supportsStreaming = false;
+  }
+  /**
+   * Build generic REST payload
+   * Can be customized via connectorConfig
+   */
+  buildPayload(request) {
+    return {
+      prompt: request.testCase.initialPrompt,
+      context: request.testCase.context,
+      model: request.modelId,
+      tools: request.testCase.tools
+    };
+  }
+  /**
+   * Execute REST request
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    const payload = request.payload || this.buildPayload(request);
+    const headers = this.buildAuthHeaders(auth);
+    this.debug("Executing REST request");
+    this.debug("Endpoint:", endpoint);
+    this.debug("Payload:", JSON.stringify(payload).substring(0, 500));
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`REST 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.runId || data.id || null,
+      rawEvents: [data],
+      metadata: {
+        status: response.status,
+        responseHeaders: Object.fromEntries(response.headers.entries())
+      }
+    };
+  }
+  /**
+   * Parse REST response into trajectory steps
+   * This is a generic implementation - subclass for specific APIs
+   */
+  parseResponse(data) {
+    const steps = [];
+    if (data.thinking) {
+      steps.push(this.createStep("thinking", data.thinking));
+    }
+    if (data.toolCalls && Array.isArray(data.toolCalls)) {
+      for (const call of data.toolCalls) {
+        steps.push(this.createStep("action", `Calling ${call.name}...`, {
+          toolName: call.name,
+          toolArgs: call.args || call.input
+        }));
+        if (call.result !== void 0) {
+          steps.push(this.createStep(
+            "tool_result",
+            typeof call.result === "string" ? call.result : JSON.stringify(call.result),
+            { status: "SUCCESS" }
+          ));
+        }
+      }
+    }
+    const responseContent = data.response || data.content || data.answer || data.text || data.message;
+    if (responseContent) {
+      steps.push(this.createStep(
+        "response",
+        typeof responseContent === "string" ? responseContent : JSON.stringify(responseContent)
+      ));
+    }
+    if (data.inference_results) {
+      const outputs = data.inference_results[0]?.output || [];
+      for (const output of outputs) {
+        if (output.name === "response") {
+          const content = output.dataAsMap?.response || output.result;
+          if (content) {
+            steps.push(this.createStep("response", content));
+          }
+        }
+      }
+    }
+    if (steps.length === 0 && data) {
+      steps.push(this.createStep("response", JSON.stringify(data, null, 2)));
+    }
+    return steps;
+  }
+};
+var restConnector = new RESTConnector();
+
+// services/connectors/subprocess/SubprocessConnector.ts
+import { spawn } from "child_process";
+var DEFAULT_SUBPROCESS_CONFIG = {
+  command: "",
+  args: [],
+  env: {},
+  inputMode: "stdin",
+  outputParser: "text",
+  timeout: 3e5
+  // 5 minutes
+};
+var SubprocessConnector = class extends BaseConnector {
+  constructor(config) {
+    super();
+    this.type = "subprocess";
+    this.name = "Subprocess (CLI)";
+    this.supportsStreaming = true;
+    this.config = { ...DEFAULT_SUBPROCESS_CONFIG, ...config };
+  }
+  /**
+   * Build input for the subprocess
+   */
+  buildPayload(request) {
+    let prompt = request.testCase.initialPrompt;
+    if (request.testCase.context && request.testCase.context.length > 0) {
+      const contextStr = request.testCase.context.map((c) => `${c.description}: ${c.value}`).join("\n");
+      prompt = `Context:
+${contextStr}
+
+Question: ${prompt}`;
+    }
+    return prompt;
+  }
+  /**
+   * Execute subprocess and capture output
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    this.debug("========== execute() STARTED ==========");
+    const command = endpoint || this.config.command;
+    const args = this.config.args || [];
+    const input = request.payload || this.buildPayload(request);
+    this.debug("Command:", command);
+    this.debug("Args:", args);
+    this.debug("Input mode:", this.config.inputMode);
+    this.debug("Output parser:", this.config.outputParser);
+    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());
+    const env = {
+      ...process.env,
+      ...this.buildAuthEnv(auth),
+      ...this.config.env
+    };
+    return new Promise((resolve, reject) => {
+      const trajectory = [];
+      const rawOutput = [];
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      const finalArgs = this.config.inputMode === "arg" ? [...args, input] : args;
+      this.debug("Spawning process...");
+      this.debug("Full command:", command, finalArgs.join(" "));
+      const proc = spawn(command, finalArgs, {
+        env,
+        cwd: this.config.workingDir,
+        shell: true
+      });
+      this.debug("Process spawned, PID:", proc.pid);
+      const timeoutId = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        this.debug("TIMEOUT reached, killing process");
+        proc.kill("SIGTERM");
+        reject(new Error(`Subprocess timed out after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+      if (this.config.inputMode === "stdin") {
+        this.debug("Writing input to stdin...");
+        proc.stdin.write(input);
+        proc.stdin.end();
+        this.debug("stdin closed");
+      }
+      proc.stdout.on("data", (data) => {
+        const chunk = data.toString();
+        this.debug("stdout received:", chunk.length, "bytes");
+        this.debug("stdout preview:", chunk.substring(0, 200));
+        stdout += chunk;
+        rawOutput.push({ type: "stdout", data: chunk, timestamp: Date.now() });
+        onRawEvent?.({ type: "stdout", data: chunk });
+        if (this.config.outputParser === "streaming") {
+          this.parseStreamingOutput(chunk, trajectory, onProgress);
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        const chunk = data.toString();
+        this.debug("stderr received:", chunk.length, "bytes");
+        this.debug("stderr:", chunk);
+        stderr += chunk;
+        onRawEvent?.({ type: "stderr", data: chunk });
+        this.debug("stderr:", chunk);
+      });
+      proc.on("close", (code, signal) => {
+        this.debug("Process closed with code:", code, "signal:", signal);
+        clearTimeout(timeoutId);
+        if (settled) return;
+        settled = true;
+        if (code !== 0) {
+          this.debug("Non-zero exit code:", code);
+          this.error(`Process exited with code ${code}`);
+          this.error("stderr:", stderr);
+        }
+        const finalTrajectory = this.config.outputParser === "streaming" ? trajectory : this.parseResponse({ stdout, stderr, exitCode: code });
+        if (this.config.outputParser !== "streaming") {
+          finalTrajectory.forEach((step) => onProgress?.(step));
+        }
+        this.debug("Resolving with trajectory of", finalTrajectory.length, "steps");
+        resolve({
+          trajectory: finalTrajectory,
+          runId: `subprocess-${Date.now()}`,
+          rawEvents: rawOutput,
+          metadata: {
+            command,
+            args: finalArgs,
+            exitCode: code,
+            stderr: stderr || void 0
+          }
+        });
+      });
+      proc.on("error", (error) => {
+        this.debug("ERROR event:", error.message);
+        clearTimeout(timeoutId);
+        if (settled) return;
+        settled = true;
+        let errorMsg = `Failed to spawn subprocess: ${error.message}`;
+        if (error.message.includes("ENOENT")) {
+          errorMsg = `Command '${command}' not found. Is it installed and in PATH?`;
+          console.error(`[Subprocess] ENOENT error - command '${command}' not found in PATH`);
+        } else if (error.message.includes("EACCES")) {
+          errorMsg = `Permission denied executing '${command}'. Check file permissions.`;
+          console.error(`[Subprocess] EACCES error - permission denied for '${command}'`);
+        } else if (error.message.includes("EPERM")) {
+          errorMsg = `Operation not permitted for '${command}'. May require elevated privileges.`;
+          console.error(`[Subprocess] EPERM error - operation not permitted`);
+        }
+        reject(new Error(errorMsg));
+      });
+    });
+    this.debug("========== execute() COMPLETED ==========");
+  }
+  /**
+   * Parse streaming output and emit steps in real-time
+   */
+  parseStreamingOutput(chunk, trajectory, onProgress) {
+    const lines = chunk.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      const step = this.createStep("assistant", line);
+      trajectory.push(step);
+      onProgress?.(step);
+    }
+  }
+  /**
+   * Parse final subprocess output
+   */
+  parseResponse(data) {
+    const steps = [];
+    if (this.config.outputParser === "json") {
+      try {
+        const parsed = JSON.parse(data.stdout);
+        return this.parseJsonOutput(parsed);
+      } catch {
+        this.debug("Failed to parse JSON output, falling back to text");
+      }
+    }
+    if (data.stdout.trim()) {
+      steps.push(this.createStep("response", data.stdout.trim()));
+    }
+    if (data.exitCode !== 0 && data.stderr.trim()) {
+      steps.push(this.createStep("tool_result", `Error: ${data.stderr.trim()}`, {
+        status: "FAILURE"
+      }));
+    }
+    return steps;
+  }
+  /**
+   * Parse JSON output into trajectory steps
+   */
+  parseJsonOutput(data) {
+    const steps = [];
+    if (data.thinking) {
+      steps.push(this.createStep("thinking", data.thinking));
+    }
+    if (data.steps && Array.isArray(data.steps)) {
+      for (const step of data.steps) {
+        steps.push(this.createStep(step.type || "assistant", step.content, {
+          toolName: step.toolName,
+          toolArgs: step.toolArgs
+        }));
+      }
+    }
+    if (data.response || data.answer || data.content) {
+      steps.push(this.createStep("response", data.response || data.answer || data.content));
+    }
+    return steps;
+  }
+  /**
+   * Health check - verify command exists
+   */
+  async healthCheck(endpoint, auth) {
+    const command = endpoint || this.config.command;
+    if (!command) return false;
+    return new Promise((resolve) => {
+      const proc = spawn("which", [command], { shell: true });
+      proc.on("close", (code) => resolve(code === 0));
+      proc.on("error", () => resolve(false));
+    });
+  }
+};
+var subprocessConnector = new SubprocessConnector();
+
+// services/connectors/claude-code/ClaudeCodeConnector.ts
+var CLAUDE_CODE_DEFAULT_CONFIG = {
+  command: "claude",
+  args: ["--print", "--verbose", "--output-format", "stream-json"],
+  // Structured JSON output (--verbose required with stream-json)
+  env: {
+    // These can be overridden by agent config or environment
+    DISABLE_PROMPT_CACHING: "1",
+    DISABLE_ERROR_REPORTING: "1"
+    // Note: DISABLE_TELEMETRY removed - telemetry enabled by default
+    // Configure OTEL_EXPORTER_OTLP_ENDPOINT in .env to send traces
+  },
+  inputMode: "stdin",
+  outputParser: "streaming",
+  timeout: 6e5
+  // 10 minutes for Claude Code
+};
+var ClaudeCodeConnector = class extends SubprocessConnector {
+  constructor(config) {
+    super({ ...CLAUDE_CODE_DEFAULT_CONFIG, ...config });
+    this.type = "claude-code";
+    this.name = "Claude Code CLI";
+    this.outputBuffer = "";
+    this.thinkingBuffer = "";
+    this.isInThinking = false;
+  }
+  /**
+   * Build prompt for Claude Code
+   * Structures the input to get the best RCA results
+   */
+  buildPayload(request) {
+    const parts = [];
+    if (request.testCase.context && request.testCase.context.length > 0) {
+      parts.push("## Context");
+      for (const ctx of request.testCase.context) {
+        parts.push(`**${ctx.description}:**`);
+        parts.push(ctx.value);
+        parts.push("");
+      }
+    }
+    parts.push("## Task");
+    parts.push(request.testCase.initialPrompt);
+    return parts.join("\n");
+  }
+  /**
+   * Parse Claude Code streaming output (stream-json format)
+   * Each line is a JSON object with type and content
+   */
+  parseStreamingOutput(chunk, trajectory, onProgress) {
+    this.outputBuffer += chunk;
+    const lines = this.outputBuffer.split("\n");
+    this.outputBuffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const event = JSON.parse(trimmed);
+        const steps = this.parseJsonEvent(event);
+        for (const step of steps) {
+          trajectory.push(step);
+          onProgress?.(step);
+        }
+      } catch {
+        if (trimmed) {
+          const step = this.createStep("assistant", trimmed);
+          trajectory.push(step);
+          onProgress?.(step);
+        }
+      }
+    }
+  }
+  /**
+   * Parse a single JSON event from stream-json output
+   */
+  parseJsonEvent(event) {
+    const steps = [];
+    if (event.type === "assistant" && event.message?.content) {
+      for (const block of event.message.content) {
+        if (block.type === "thinking" && block.thinking) {
+          steps.push(this.createStep("thinking", block.thinking));
+        } else if (block.type === "text" && block.text) {
+          steps.push(this.createStep("assistant", block.text));
+        } else if (block.type === "tool_use") {
+          steps.push(this.createStep("action", JSON.stringify(block.input || {}), {
+            toolName: block.name,
+            toolArgs: block.input
+          }));
+        }
+      }
+    } else if (event.type === "content_block_delta") {
+      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));
+      }
+    } 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",
+        typeof event.result === "string" ? event.result : JSON.stringify(event.result)
+      ));
+    } else if (event.type === "tool_result") {
+      steps.push(this.createStep(
+        "tool_result",
+        typeof event.content === "string" ? event.content : JSON.stringify(event.content),
+        { status: event.is_error ? "FAILURE" /* FAILURE */ : "SUCCESS" /* SUCCESS */ }
+      ));
+    }
+    return steps;
+  }
+  /**
+   * Parse final output for Claude Code
+   */
+  parseResponse(data) {
+    const steps = [];
+    let content = data.stdout;
+    const thinkingMatches = content.matchAll(/<thinking>([\s\S]*?)<\/thinking>/g);
+    for (const match of thinkingMatches) {
+      const thinking = match[1].trim();
+      if (thinking) {
+        steps.push(this.createStep("thinking", thinking));
+      }
+      content = content.replace(match[0], "");
+    }
+    const response = content.trim();
+    if (response) {
+      steps.push(this.createStep("response", response));
+    }
+    if (data.exitCode !== 0 && data.stderr.trim()) {
+      steps.push(this.createStep("tool_result", `Error: ${data.stderr.trim()}`, {
+        status: "FAILURE" /* FAILURE */
+      }));
+    }
+    return steps;
+  }
+  /**
+   * Reset state for new execution
+   */
+  resetState() {
+    this.outputBuffer = "";
+    this.thinkingBuffer = "";
+    this.isInThinking = false;
+  }
+  /**
+   * Override execute to reset state
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    this.debug("========== execute() STARTED ==========");
+    this.debug("Endpoint:", endpoint);
+    this.debug("Test case:", request.testCase.name);
+    this.debug("Config:", this["config"]);
+    this.resetState();
+    this.debug("State reset, calling super.execute()...");
+    const result = await super.execute(endpoint, request, auth, onProgress, onRawEvent);
+    this.debug("super.execute() returned with", result.trajectory.length, "steps");
+    this.debug("========== execute() COMPLETED ==========");
+    return result;
+  }
+  /**
+   * Health check - verify claude command exists
+   */
+  async healthCheck(endpoint, auth) {
+    return super.healthCheck(endpoint || "claude", auth);
+  }
+};
+var claudeCodeConnector = new ClaudeCodeConnector();
+
+// services/connectors/mock/MockConnector.ts
+var MockConnector = class extends BaseConnector {
+  constructor() {
+    super(...arguments);
+    this.type = "mock";
+    this.name = "Demo Agent (Mock)";
+    this.supportsStreaming = true;
+  }
+  /**
+   * Build payload - not used for mock but required by interface
+   */
+  buildPayload(request) {
+    return {
+      question: request.testCase.initialPrompt,
+      context: request.testCase.context
+    };
+  }
+  /**
+   * Execute mock request - generates realistic trajectory with delays
+   */
+  async execute(endpoint, request, auth, onProgress, onRawEvent) {
+    const trajectory = [];
+    const rawEvents = [];
+    const runId = `mock-run-${Date.now()}`;
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    this.debug("Generating mock trajectory for:", request.testCase.name);
+    const emitStep = (step) => {
+      trajectory.push(step);
+      onProgress?.(step);
+      rawEvents.push({ type: "MOCK_STEP", step });
+      onRawEvent?.({ type: "MOCK_STEP", step });
+    };
+    await sleep(100);
+    emitStep(this.createStep(
+      "assistant",
+      "I need to investigate this issue. Let me start by checking the cluster health and then drill down into specific metrics."
+    ));
+    await sleep(300);
+    emitStep(this.createStep(
+      "action",
+      "Calling opensearch_cluster_health...",
+      {
+        toolName: "opensearch_cluster_health",
+        toolArgs: { local: true }
+      }
+    ));
+    await sleep(500);
+    emitStep(this.createStep(
+      "tool_result",
+      JSON.stringify({ status: "yellow", number_of_nodes: 3, unassigned_shards: 0 }, null, 2),
+      {
+        status: "SUCCESS",
+        latencyMs: 500
+      }
+    ));
+    await sleep(300);
+    emitStep(this.createStep(
+      "assistant",
+      "The cluster is in yellow state. Let me check the node stats to identify which node might be causing issues."
+    ));
+    await sleep(300);
+    emitStep(this.createStep(
+      "action",
+      "Calling opensearch_nodes_stats...",
+      {
+        toolName: "opensearch_nodes_stats",
+        toolArgs: { metric: "jvm,os" }
+      }
+    ));
+    await sleep(600);
+    emitStep(this.createStep(
+      "tool_result",
+      "Node-1: CPU 12%, JVM Heap 45%\nNode-2: CPU 15%, JVM Heap 52%\nNode-3: CPU 98%, JVM Heap 89% (Data Node)",
+      {
+        status: "SUCCESS",
+        latencyMs: 600
+      }
+    ));
+    await sleep(400);
+    emitStep(this.createStep(
+      "response",
+      `## Root Cause Analysis Complete
+
+**Finding:** High CPU utilization detected on Node-3 (98% CPU, 89% JVM Heap)
+
+**Root Cause:** Node-3 is experiencing resource exhaustion, likely due to:
+1. Heavy indexing or search operations
+2. Garbage collection pressure from high heap usage
+3. Possible hot spot in shard distribution
+
+**Recommendations:**
+1. Check hot threads on Node-3 using \`_nodes/Node-3/hot_threads\`
+2. Review shard distribution and consider rebalancing
+3. Monitor GC logs for long pauses
+4. Consider scaling horizontally if load persists`
+    ));
+    this.debug("Mock trajectory completed. Steps:", trajectory.length);
+    return {
+      trajectory,
+      runId,
+      rawEvents,
+      metadata: {
+        mock: true,
+        testCaseId: request.testCase.id,
+        testCaseName: request.testCase.name
+      }
+    };
+  }
+  /**
+   * Parse raw events - for mock, just extract steps from our custom format
+   */
+  parseResponse(rawEvents) {
+    return rawEvents.filter((e) => e.type === "MOCK_STEP" && e.step).map((e) => e.step);
+  }
+  /**
+   * Health check - mock is always "healthy"
+   */
+  async healthCheck(endpoint, auth) {
+    return true;
+  }
+};
+var mockConnector = new MockConnector();
+
+// services/connectors/registry.ts
+var DEFAULT_CONNECTOR_TYPE = "agui-streaming";
+var ConnectorRegistryImpl = class {
+  constructor() {
+    this.connectors = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a connector implementation
+   * @throws Error if connector with same type is already registered
+   */
+  register(connector) {
+    if (this.connectors.has(connector.type)) {
+      console.warn(
+        `[ConnectorRegistry] Overwriting existing connector for type: ${connector.type}`
+      );
+    }
+    this.connectors.set(connector.type, connector);
+  }
+  /**
+   * Get a connector by protocol type
+   */
+  get(type) {
+    return this.connectors.get(type);
+  }
+  /**
+   * Get all registered connectors
+   */
+  getAll() {
+    return Array.from(this.connectors.values());
+  }
+  /**
+   * Check if a connector is registered
+   */
+  has(type) {
+    return this.connectors.has(type);
+  }
+  /**
+   * Get connector for an agent config
+   * Handles backwards compatibility with legacy configs
+   *
+   * Resolution order:
+   * 1. If endpoint starts with 'mock://', use mock connector
+   * 2. If connectorType is specified, use that
+   * 3. Default to 'agui-streaming'
+   */
+  getForAgent(agent) {
+    if (agent.endpoint.startsWith("mock://")) {
+      const mockConnector2 = this.get("mock");
+      if (mockConnector2) {
+        return mockConnector2;
+      }
+      console.warn("[ConnectorRegistry] Mock connector not registered, falling back to default");
+    }
+    const connectorType = agent.connectorType ?? DEFAULT_CONNECTOR_TYPE;
+    const connector = this.get(connectorType);
+    if (!connector) {
+      console.error(
+        `[ConnectorRegistry] Connector not found for type: ${connectorType}, falling back to ${DEFAULT_CONNECTOR_TYPE}`
+      );
+      const defaultConnector = this.get(DEFAULT_CONNECTOR_TYPE);
+      if (!defaultConnector) {
+        throw new Error(
+          `No connector registered for type '${connectorType}' and no default connector available`
+        );
+      }
+      return defaultConnector;
+    }
+    return connector;
+  }
+  /**
+   * Clear all registered connectors (useful for testing)
+   */
+  clear() {
+    this.connectors.clear();
+  }
+  /**
+   * Get list of registered connector types
+   */
+  getRegisteredTypes() {
+    return Array.from(this.connectors.keys());
+  }
+};
+var connectorRegistry = new ConnectorRegistryImpl();
+function registerConnector(connector) {
+  connectorRegistry.register(connector);
+}
+export {
+  AGUIStreamingConnector,
+  BaseConnector,
+  ClaudeCodeConnector,
+  MockConnector,
+  RESTConnector,
+  SubprocessConnector,
+  connectorRegistry,
+  defineConfig,
+  registerConnector
+};