netra-sdk 1.0.3 → 1.0.5

package/dist/index.js

@@ -10,6 +10,8 @@ import { CompositePropagator, W3CTraceContextPropagator, W3CBaggagePropagator, E
 import * as http from 'http';
 import * as https from 'https';
 import { JsonTraceSerializer } from '@opentelemetry/otlp-transformer';
+import pLimit from 'p-limit';
+import axios from 'axios';
 
 // src/api/http-client.ts
 var NetraHttpClient = class {
@@ -348,6 +350,8 @@ var Measure = /* @__PURE__ */ ((Measure2) => {
   Measure2["TOTAL_COST"] = "Total Cost";
   Measure2["VIOLATIONS"] = "Violations";
   Measure2["TOTAL_TOKENS"] = "Total Tokens";
+  Measure2["AUDIO_DURATION"] = "Audio Duration";
+  Measure2["CHARACTER_COUNT"] = "Character Count";
   return Measure2;
 })(Measure || {});
 var Aggregation = /* @__PURE__ */ ((Aggregation2) => {
@@ -8821,6 +8825,445 @@ function uninstrumentAll() {
     console.debug("Failed to uninstrument TypeORM:", e);
   }
 }
+var LOG_PREFIX = "netra.simulation";
+var DEFAULT_TIMEOUT = 1e4;
+var SimulationHttpClient = class {
+  constructor(config2) {
+    this.client = null;
+    this.client = this._createClient(config2);
+  }
+  /**
+   * Create and configure the HTTP client.
+   */
+  _createClient(config2) {
+    const endpoint = (config2.otlpEndpoint || "").trim();
+    if (!endpoint) {
+      console.error(`${LOG_PREFIX}: NETRA_OTLP_ENDPOINT is required`);
+      return null;
+    }
+    const baseURL = this._resolveBaseUrl(endpoint);
+    const headers = this._buildHeaders(config2);
+    const timeout = this._getTimeout();
+    try {
+      return axios.create({
+        baseURL,
+        headers,
+        timeout
+      });
+    } catch (error) {
+      console.error(`${LOG_PREFIX}: Failed to create HTTP client:`, error);
+      return null;
+    }
+  }
+  /**
+   * Extract base URL, removing telemetry suffix if present.
+   */
+  _resolveBaseUrl(endpoint) {
+    let baseUrl = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+    if (baseUrl.endsWith("/telemetry")) {
+      baseUrl = baseUrl.slice(0, -"/telemetry".length);
+    }
+    return baseUrl;
+  }
+  /**
+   * Build request headers from configuration.
+   */
+  _buildHeaders(config2) {
+    const headers = { ...config2.headers };
+    if (config2.apiKey) {
+      headers["x-api-key"] = config2.apiKey;
+    }
+    return headers;
+  }
+  /**
+   * Get timeout from environment or use default.
+   */
+  _getTimeout() {
+    const timeoutStr = process.env.NETRA_SIMULATION_TIMEOUT;
+    if (!timeoutStr) {
+      return DEFAULT_TIMEOUT;
+    }
+    const timeout = parseFloat(timeoutStr);
+    if (isNaN(timeout)) {
+      console.warn(
+        `${LOG_PREFIX}: Invalid timeout '${timeoutStr}', using default ${DEFAULT_TIMEOUT}ms`
+      );
+      return DEFAULT_TIMEOUT;
+    }
+    return timeout * 1e3;
+  }
+  /**
+   * Create a new simulation run for the specified dataset.
+   */
+  async createRun(name, datasetId, context13) {
+    if (!this.client) {
+      console.error(`${LOG_PREFIX}: Client not initialized`);
+      return null;
+    }
+    try {
+      const url = "/evaluations/test_run/multi-turn";
+      const payload = {
+        name,
+        datasetId,
+        context: context13 || {}
+      };
+      const response = await this.client.post(url, payload);
+      const data = response.data;
+      const responseData = data.data || {};
+      const userMessages = responseData.userMessages || [];
+      if (userMessages.length === 0) {
+        console.warn(`${LOG_PREFIX}: No user messages returned from create_run`);
+        return null;
+      }
+      const runId = responseData.id || "";
+      const simulationItems = userMessages.map(
+        (msg) => ({
+          runItemId: msg.testRunItemId || "",
+          message: msg.userMessage || "",
+          turnId: msg.turnId || ""
+        })
+      );
+      return {
+        runId,
+        simulationItems
+      };
+    } catch (error) {
+      const errorMsg = this._extractErrorMessage(error);
+      console.error(`${LOG_PREFIX}: Failed to create simulation run:`, errorMsg);
+      return null;
+    }
+  }
+  /**
+   * Send a conversation turn to the backend and get the next response.
+   */
+  async triggerConversation(message, turnId, sessionId, traceId) {
+    if (!this.client) {
+      console.error(`${LOG_PREFIX}: Client not initialized`);
+      return null;
+    }
+    try {
+      const url = "/evaluations/turn/agent-response";
+      const payload = {
+        turnId,
+        agentResponse: { message },
+        sessionId,
+        traceId
+      };
+      const response = await this.client.post(url, payload);
+      const data = response.data;
+      const responseData = data.data || {};
+      const decision = responseData.decision || "continue";
+      if (decision === "stop") {
+        return {
+          decision,
+          reason: responseData.reason || ""
+        };
+      }
+      const userMessages = responseData.userMessages || [];
+      if (userMessages.length === 0) {
+        console.warn(`${LOG_PREFIX}: No user messages in continue response`);
+        return null;
+      }
+      const nextMsg = userMessages[0];
+      return {
+        decision,
+        nextTurnId: nextMsg.turnId || "",
+        nextUserMessage: nextMsg.userMessage || "",
+        nextRunItemId: nextMsg.testRunItemId || ""
+      };
+    } catch (error) {
+      const errorMsg = this._extractErrorMessage(error);
+      console.error(`${LOG_PREFIX}: Failed to trigger conversation:`, errorMsg);
+      return null;
+    }
+  }
+  /**
+   * Report a task execution failure to the backend.
+   */
+  async reportFailure(runId, runItemId, error) {
+    if (!this.client) {
+      console.error(`${LOG_PREFIX}: Client not initialized`);
+      return;
+    }
+    try {
+      const url = `/evaluations/run/${runId}/item/${runItemId}/status`;
+      const payload = { status: "failed", failureReason: error };
+      await this.client.patch(url, payload);
+      console.info(`${LOG_PREFIX}: Reported failure - ${error}`);
+    } catch (err) {
+      const errorMsg = this._extractErrorMessage(err);
+      console.error(`${LOG_PREFIX}: Failed to report failure:`, errorMsg);
+    }
+  }
+  /**
+   * Submit the run status.
+   */
+  async postRunStatus(runId, status) {
+    if (!this.client) {
+      console.error(
+        `${LOG_PREFIX}: Client not initialized; cannot post run status`
+      );
+      return { success: false };
+    }
+    try {
+      const url = `/evaluations/run/${runId}/status`;
+      const payload = { status };
+      const response = await this.client.post(url, payload);
+      const data = response.data;
+      if (data && typeof data === "object" && "data" in data) {
+        console.info(`${LOG_PREFIX}: Completed test run successfully`);
+        return data.data || {};
+      }
+      return data;
+    } catch (error) {
+      const errorMsg = this._extractErrorMessage(error);
+      console.error(
+        `${LOG_PREFIX}: Failed to post run status for run '${runId}':`,
+        errorMsg
+      );
+      return { success: false };
+    }
+  }
+  /**
+   * Extract error message from response or exception.
+   */
+  _extractErrorMessage(error) {
+    if (axios.isAxiosError(error)) {
+      const axiosError = error;
+      if (axiosError.response?.data) {
+        const responseData = axiosError.response.data;
+        if (typeof responseData === "object" && responseData.error && typeof responseData.error === "object") {
+          return responseData.error.message || error.message;
+        }
+      }
+      return axiosError.message;
+    }
+    return error?.message || String(error);
+  }
+};
+
+// src/simulation/task.ts
+var BaseTask = class {
+};
+
+// src/simulation/utils.ts
+var LOG_PREFIX2 = "netra.simulation";
+function validateSimulationInputs(datasetId, task2) {
+  if (!datasetId) {
+    console.error(`${LOG_PREFIX2}: dataset_id is required`);
+    return false;
+  }
+  if (!(task2 instanceof BaseTask)) {
+    console.error(`${LOG_PREFIX2}: task must be a BaseTask instance`);
+    return false;
+  }
+  return true;
+}
+async function executeTask2(task2, message, sessionId) {
+  const result = task2.run(message, sessionId);
+  const resolvedResult = result instanceof Promise ? await result : result;
+  if (typeof resolvedResult === "object" && resolvedResult !== null && "message" in resolvedResult && "sessionId" in resolvedResult) {
+    return [resolvedResult.message, resolvedResult.sessionId];
+  }
+  throw new Error(
+    `Task must return TaskResult, got ${typeof resolvedResult}`
+  );
+}
+
+// src/simulation/api.ts
+var LOG_PREFIX3 = "netra.simulation";
+var SPAN_NAME = "Netra.Simulation.TestRun";
+var Simulation = class {
+  constructor(config2) {
+    this._config = config2;
+    this._client = new SimulationHttpClient(config2);
+  }
+  /**
+   * Run a multi-turn conversation simulation.
+   *
+   * @param options - Simulation configuration options
+   * @returns Dictionary with simulation results, or null on failure
+   */
+  async runSimulation(options) {
+    const {
+      name,
+      datasetId,
+      task: task2,
+      context: context13,
+      maxConcurrency = 5
+    } = options;
+    if (!validateSimulationInputs(datasetId, task2)) {
+      return null;
+    }
+    const startTime = Date.now();
+    const runResult = await this._client.createRun(name, datasetId, context13);
+    if (!runResult) {
+      return null;
+    }
+    const { runId, simulationItems } = runResult;
+    if (!simulationItems || simulationItems.length === 0) {
+      console.error(`${LOG_PREFIX3}: No items returned from create_run`);
+      return null;
+    }
+    let interrupted = false;
+    const proc = typeof process !== "undefined" ? process : void 0;
+    const finalizeFailure = (signal) => {
+      if (interrupted) {
+        return;
+      }
+      interrupted = true;
+      proc?.removeListener("SIGINT", handleSignal);
+      proc?.removeListener("SIGTERM", handleSignal);
+      proc?.removeListener("uncaughtException", handleException);
+      proc?.removeListener("unhandledRejection", handleRejection);
+      void this._client.postRunStatus(runId, "failed").finally(() => {
+        if (signal) {
+          proc?.kill(proc.pid, signal);
+        }
+      });
+    };
+    const handleSignal = (signal) => {
+      finalizeFailure(signal);
+    };
+    const handleException = () => {
+      finalizeFailure();
+    };
+    const handleRejection = () => {
+      finalizeFailure();
+    };
+    if (proc && typeof proc.once === "function") {
+      proc.once("SIGINT", handleSignal);
+      proc.once("SIGTERM", handleSignal);
+      proc.once("uncaughtException", handleException);
+      proc.once("unhandledRejection", handleRejection);
+    }
+    console.info(
+      `${LOG_PREFIX3}: Starting simulation with ${simulationItems.length} items`
+    );
+    try {
+      const result = await this._runSimulationAsync(
+        runId,
+        simulationItems,
+        task2,
+        maxConcurrency
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      console.info(
+        `${LOG_PREFIX3}: Simulation completed in ${elapsedTime} seconds`
+      );
+      return result;
+    } catch (error) {
+      console.error(`${LOG_PREFIX3}: Run simulation failed`);
+      await this._client.postRunStatus(runId, "failed");
+      throw error;
+    } finally {
+      if (proc && typeof proc.removeListener === "function") {
+        proc.removeListener("SIGINT", handleSignal);
+        proc.removeListener("SIGTERM", handleSignal);
+        proc.removeListener("uncaughtException", handleException);
+        proc.removeListener("unhandledRejection", handleRejection);
+      }
+    }
+  }
+  /**
+   * Async implementation of run_simulation with concurrency control.
+   */
+  async _runSimulationAsync(runId, runItems, task2, maxConcurrency) {
+    const results = {
+      success: true,
+      completed: [],
+      failed: [],
+      totalItems: runItems.length
+    };
+    let processedCount = 0;
+    const limit = pLimit(Math.min(5, maxConcurrency));
+    const promises = runItems.map(
+      (runItem) => limit(async () => {
+        const result = await this._executeConversation(runId, runItem, task2);
+        if (result.success) {
+          results.completed.push(result);
+        } else {
+          results.failed.push(result);
+        }
+        processedCount++;
+        console.info(
+          `${LOG_PREFIX3}: ${processedCount}/${runItems.length} processed (run_item_id=${runItem.runItemId})`
+        );
+        return result;
+      })
+    );
+    await Promise.all(promises);
+    console.info(
+      `${LOG_PREFIX3}: Completed=${results.completed.length}, Failed=${results.failed.length}`
+    );
+    await this._client.postRunStatus(runId, "completed");
+    return results;
+  }
+  /**
+   * Execute a multi-turn conversation for a single simulation item.
+   */
+  async _executeConversation(runId, runItem, task2) {
+    const { runItemId, message: initialMessage, turnId: initialTurnId } = runItem;
+    let message = initialMessage;
+    let turnId = initialTurnId;
+    let sessionId = null;
+    while (true) {
+      try {
+        const span2 = new SpanWrapper(SPAN_NAME, {}, LOG_PREFIX3);
+        span2.start();
+        const traceId = span2.getCurrentSpan()?.spanContext().traceId ?? "";
+        const [responseMessage, taskSessionId] = await executeTask2(
+          task2,
+          message,
+          sessionId
+        );
+        if (taskSessionId) {
+          sessionId = taskSessionId;
+        }
+        span2.end();
+        const response = await this._client.triggerConversation(
+          responseMessage,
+          turnId,
+          sessionId || "",
+          traceId
+        );
+        if (response === null) {
+          const errorMsg = "Failed to get conversation response";
+          return {
+            runItemId,
+            success: false,
+            error: errorMsg,
+            turnId
+          };
+        }
+        if (response.decision === "stop") {
+          console.info(
+            `${LOG_PREFIX3}: Completed run_item_id=${runItemId} reason=${response.reason}`
+          );
+          return {
+            runItemId,
+            success: true,
+            finalTurnId: turnId
+          };
+        }
+        message = response.nextUserMessage;
+        turnId = response.nextTurnId;
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(
+          `${LOG_PREFIX3}: Task failed run_item_id=${runItemId}, turn_id=${turnId}: ${errorMsg}`
+        );
+        await this._client.reportFailure(runId, runItemId, errorMsg);
+        return {
+          runItemId,
+          success: false,
+          error: errorMsg,
+          turnId
+        };
+      }
+    }
+  }
+};
 function serializeValue(value) {
   try {
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
@@ -9016,6 +9459,15 @@ function span(targetOrOptions, options) {
 // src/index.ts
 var _rootSpan;
 var Netra = class {
+  /**
+   * Get the current Netra configuration
+   */
+  static getConfig() {
+    if (!this._config) {
+      throw new Error("Netra SDK not initialized. Call Netra.init() first.");
+    }
+    return this._config;
+  }
   /**
    * Check if Netra has been initialized
    */
@@ -9061,6 +9513,7 @@ var Netra = class {
     this.usage = new Usage(cfg);
     this.evaluation = new Evaluation(cfg);
     this.dashboard = new Dashboard(cfg);
+    this.simulation = new Simulation(cfg);
     this._initialized = true;
     console.info("Netra successfully initialized.");
     if (cfg.debugMode) {
@@ -9349,6 +9802,6 @@ Netra._initialized = false;
 Netra.withBlockedSpansLocal = withBlockedSpansLocal;
 var index_default = Netra;
 
-export { Aggregation, ChartType, Config, ConversationType, Dashboard, DimensionField, EntryStatus, Evaluation, FilterField, FilterType, FilteringSpanExporter, GroupBy, InstrumentationSpanProcessor, Measure, Netra, NetraInstruments, Operator, RunEntryContext, RunStatus, Scope, ScrubbingSpanProcessor, SessionSpanProcessor, SpanType, TrialAwareOTLPExporter, Usage, agent, index_default as default, metadataField, mistralAIInstrumentor, span, task, workflow };
+export { Aggregation, BaseTask, ChartType, Config, ConversationType, Dashboard, DimensionField, EntryStatus, Evaluation, FilterField, FilterType, FilteringSpanExporter, GroupBy, InstrumentationSpanProcessor, Measure, Netra, NetraInstruments, Operator, RunEntryContext, RunStatus, Scope, ScrubbingSpanProcessor, SessionSpanProcessor, Simulation, SpanType, TrialAwareOTLPExporter, Usage, agent, index_default as default, metadataField, mistralAIInstrumentor, span, task, workflow };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map