aigie-sdk 0.0.1

package/dist/testing/index.mjs

@@ -0,0 +1,646 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/uuid.ts
+function uuidv7() {
+  let timestamp = Date.now();
+  if (timestamp === lastTimestamp) {
+    sequence++;
+    if (sequence > 4095) {
+      timestamp = Date.now();
+      sequence = 0;
+    }
+  } else {
+    sequence = 0;
+    lastTimestamp = timestamp;
+  }
+  const timestampHex = timestamp.toString(16).padStart(12, "0");
+  const seqHex = (7 << 12 | sequence & 4095).toString(16).padStart(4, "0");
+  const randomBits = new Uint8Array(8);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(randomBits);
+  } else {
+    for (let i = 0; i < 8; i++) {
+      randomBits[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  randomBits[0] = randomBits[0] & 63 | 128;
+  const randomHex = Array.from(randomBits).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    timestampHex.slice(0, 8),
+    timestampHex.slice(8, 12),
+    seqHex,
+    randomHex.slice(0, 4),
+    randomHex.slice(4, 16)
+  ].join("-");
+}
+var lastTimestamp, sequence;
+var init_uuid = __esm({
+  "src/utils/uuid.ts"() {
+    lastTimestamp = 0;
+    sequence = 0;
+  }
+});
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  AigieClient: () => AigieClient,
+  KyteClient: () => AigieClient,
+  getAigie: () => getAigie,
+  getKyte: () => getKyte,
+  initAigie: () => initAigie,
+  initKyte: () => initKyte
+});
+function initKyte(config) {
+  globalClient = new AigieClient(config);
+  return globalClient;
+}
+function getKyte() {
+  if (!globalClient) {
+    throw new Error("Kyte SDK not initialized. Call initKyte() first.");
+  }
+  return globalClient;
+}
+var contextStorage, globalClient, initAigie, getAigie, SpanBuilderImpl, ActiveSpanImpl, AigieClient;
+var init_client = __esm({
+  "src/client.ts"() {
+    init_uuid();
+    contextStorage = new AsyncLocalStorage();
+    globalClient = null;
+    initAigie = initKyte;
+    getAigie = getKyte;
+    SpanBuilderImpl = class {
+      client;
+      options = {};
+      constructor(client, name) {
+        this.client = client;
+        this.options.name = name;
+      }
+      setName(name) {
+        this.options.name = name;
+        return this;
+      }
+      setType(type) {
+        this.options.type = type;
+        return this;
+      }
+      setInput(input) {
+        this.options.input = input;
+        return this;
+      }
+      setMetadata(metadata) {
+        this.options.metadata = metadata;
+        return this;
+      }
+      addMetadata(key, value) {
+        this.options.metadata = { ...this.options.metadata, [key]: value };
+        return this;
+      }
+      setTags(tags) {
+        this.options.tags = tags;
+        return this;
+      }
+      addTag(tag) {
+        this.options.tags = [...this.options.tags || [], tag];
+        return this;
+      }
+      setUserId(userId) {
+        this.options.userId = userId;
+        return this;
+      }
+      setSessionId(sessionId) {
+        this.options.sessionId = sessionId;
+        return this;
+      }
+      setModelName(modelName) {
+        this.options.modelName = modelName;
+        return this;
+      }
+      start() {
+        return this.client.startSpan(this.options);
+      }
+    };
+    ActiveSpanImpl = class {
+      id;
+      traceId;
+      client;
+      span;
+      scores = [];
+      ended = false;
+      constructor(client, span) {
+        this.client = client;
+        this.span = span;
+        this.id = span.id;
+        this.traceId = span.traceId;
+      }
+      update(data) {
+        if (this.ended) {
+          console.warn("Cannot update ended span");
+          return this;
+        }
+        if (data.output) this.span.output = data.output;
+        if (data.tokens) this.span.tokens = data.tokens;
+        if (data.cost) this.span.cost = data.cost;
+        if (data.metadata) this.span.metadata = { ...this.span.metadata, ...data.metadata };
+        if (data.tags) this.span.tags = [...this.span.tags, ...data.tags];
+        if (data.modelName) this.span.modelName = data.modelName;
+        return this;
+      }
+      setOutput(output) {
+        return this.update({ output });
+      }
+      setTokens(tokens) {
+        return this.update({ tokens });
+      }
+      setCost(cost) {
+        return this.update({ cost });
+      }
+      addScore(score) {
+        this.scores.push(score);
+        return this;
+      }
+      setError(error) {
+        if (this.ended) {
+          console.warn("Cannot set error on ended span");
+          return this;
+        }
+        this.span.status = "failed";
+        this.span.errorMessage = typeof error === "string" ? error : error.message;
+        return this;
+      }
+      async end() {
+        if (this.ended) {
+          console.warn("Span already ended");
+          return;
+        }
+        this.ended = true;
+        this.span.endTime = (/* @__PURE__ */ new Date()).toISOString();
+        this.span.durationNs = (new Date(this.span.endTime).getTime() - new Date(this.span.startTime).getTime()) * 1e6;
+        if (this.span.status === "pending") {
+          this.span.status = "success";
+        }
+        await this.client.sendSpanUpdate(this.span);
+        for (const score of this.scores) {
+          await this.client.addScore(this.traceId, score, this.id);
+        }
+      }
+    };
+    AigieClient = class {
+      config;
+      eventQueue = [];
+      batchTimer = null;
+      enabled;
+      constructor(config) {
+        const rawUrl = config.apiUrl || process.env.KYTTE_URL || process.env.AIGIE_URL || process.env.AIGIE_API_URL || "";
+        const apiUrl = rawUrl.replace(/\/v1?\/?$/, "");
+        const apiKey = config.apiKey || process.env.KYTTE_TOKEN || process.env.AIGIE_TOKEN || process.env.AIGIE_API_KEY || "";
+        this.config = {
+          batchEnabled: true,
+          batchSize: 10,
+          batchTimeout: 5e3,
+          maxQueueSize: 1e3,
+          maxRetries: 1,
+          retryDelay: 2e3,
+          enabled: true,
+          ...config,
+          apiUrl,
+          apiKey
+        };
+        this.enabled = this.config.enabled ?? true;
+      }
+      // ============================================================================
+      // Enable/Disable
+      // ============================================================================
+      isEnabled() {
+        return this.enabled;
+      }
+      disable() {
+        this.enabled = false;
+      }
+      enable() {
+        this.enabled = true;
+      }
+      // ============================================================================
+      // Context Management
+      // ============================================================================
+      getCurrentContext() {
+        return contextStorage.getStore();
+      }
+      // ============================================================================
+      // Fluent Builder API
+      // ============================================================================
+      spanBuilder(name) {
+        return new SpanBuilderImpl(this, name);
+      }
+      startSpan(options) {
+        const context = this.getCurrentContext();
+        const spanId = uuidv7();
+        const traceId = context?.traceId || uuidv7();
+        const span = {
+          id: spanId,
+          traceId,
+          parentSpanId: context?.spanId || options.parentSpanId,
+          name: options.name || "unnamed-span",
+          type: options.type || "custom",
+          input: options.input || {},
+          status: "pending",
+          tags: [...this.config.defaultTags || [], ...options.tags || []],
+          metadata: { ...this.config.defaultMetadata, ...options.metadata },
+          modelName: options.modelName,
+          startTime: (/* @__PURE__ */ new Date()).toISOString(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.queueEvent(this.spanToEvent(span));
+        return new ActiveSpanImpl(this, span);
+      }
+      // ============================================================================
+      // Trace API
+      // ============================================================================
+      async trace(name, fn, options = {}) {
+        if (!this.enabled) {
+          return fn();
+        }
+        const traceId = uuidv7();
+        const trace = {
+          id: traceId,
+          name,
+          type: options.type || "chain",
+          input: options.input || {},
+          status: "pending",
+          tags: [...this.config.defaultTags || [], ...options.tags || []],
+          metadata: { ...this.config.defaultMetadata, ...options.metadata },
+          projectName: this.config.projectName,
+          userId: options.userId || this.config.defaultUserId,
+          sessionId: options.sessionId || this.config.defaultSessionId,
+          startTime: (/* @__PURE__ */ new Date()).toISOString(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const context = { traceId };
+        this.queueEvent(this.traceToEvent(trace));
+        try {
+          const result = await contextStorage.run(context, async () => {
+            return await fn();
+          });
+          trace.status = "success";
+          trace.output = { result: typeof result === "object" ? result : { value: result } };
+          trace.endTime = (/* @__PURE__ */ new Date()).toISOString();
+          trace.durationNs = (new Date(trace.endTime).getTime() - new Date(trace.startTime).getTime()) * 1e6;
+          await this.sendTraceUpdate(trace);
+          return result;
+        } catch (error) {
+          trace.status = "failed";
+          trace.errorMessage = error instanceof Error ? error.message : String(error);
+          trace.endTime = (/* @__PURE__ */ new Date()).toISOString();
+          trace.durationNs = (new Date(trace.endTime).getTime() - new Date(trace.startTime).getTime()) * 1e6;
+          await this.sendTraceUpdate(trace);
+          throw error;
+        }
+      }
+      // ============================================================================
+      // Span API
+      // ============================================================================
+      async span(name, fn, options = {}) {
+        if (!this.enabled) {
+          return fn();
+        }
+        const context = this.getCurrentContext();
+        if (!context) {
+          return this.trace(name, fn, options);
+        }
+        const spanId = uuidv7();
+        const span = {
+          id: spanId,
+          traceId: context.traceId,
+          parentSpanId: context.spanId || options.parentSpanId,
+          name,
+          type: options.type || "custom",
+          input: options.input || {},
+          status: "pending",
+          tags: [...this.config.defaultTags || [], ...options.tags || []],
+          metadata: { ...this.config.defaultMetadata, ...options.metadata },
+          modelName: options.modelName,
+          startTime: (/* @__PURE__ */ new Date()).toISOString(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const newContext = {
+          traceId: context.traceId,
+          spanId,
+          parentSpanId: context.spanId
+        };
+        this.queueEvent(this.spanToEvent(span));
+        try {
+          const result = await contextStorage.run(newContext, async () => {
+            return await fn();
+          });
+          span.status = "success";
+          span.output = { result: typeof result === "object" ? result : { value: result } };
+          span.endTime = (/* @__PURE__ */ new Date()).toISOString();
+          span.durationNs = (new Date(span.endTime).getTime() - new Date(span.startTime).getTime()) * 1e6;
+          await this.sendSpanUpdate(span);
+          return result;
+        } catch (error) {
+          span.status = "failed";
+          span.errorMessage = error instanceof Error ? error.message : String(error);
+          span.endTime = (/* @__PURE__ */ new Date()).toISOString();
+          span.durationNs = (new Date(span.endTime).getTime() - new Date(span.startTime).getTime()) * 1e6;
+          await this.sendSpanUpdate(span);
+          throw error;
+        }
+      }
+      // ============================================================================
+      // Score API
+      // ============================================================================
+      async addScore(traceId, score, spanId) {
+        if (!this.enabled) return;
+        try {
+          await this.sendToApi("/v1/scores", {
+            traceId,
+            spanId,
+            ...score
+          });
+        } catch (error) {
+          if (this.config.debug) {
+            console.error("Failed to add score:", error);
+          }
+        }
+      }
+      // ============================================================================
+      // Send APIs
+      // ============================================================================
+      async sendTraceUpdate(trace) {
+        if (!this.enabled) return;
+        const event = this.traceUpdateEvent(trace);
+        if (this.config.batchEnabled) {
+          this.queueEvent(event);
+        } else {
+          await this.sendToApi("/v1/ingestion", { batch: [event] });
+        }
+      }
+      async sendSpanUpdate(span) {
+        if (!this.enabled) return;
+        const event = this.spanUpdateEvent(span);
+        if (this.config.batchEnabled) {
+          this.queueEvent(event);
+        } else {
+          await this.sendToApi("/v1/ingestion", { batch: [event] });
+        }
+      }
+      // ============================================================================
+      // Batching
+      // ============================================================================
+      queueEvent(event) {
+        const maxSize = this.config.maxQueueSize || 1e3;
+        if (this.eventQueue.length >= maxSize) {
+          this.eventQueue.splice(0, this.eventQueue.length - maxSize + 1);
+          if (this.config.debug) {
+            console.warn(`Event queue exceeded max size (${maxSize}), dropping oldest events`);
+          }
+        }
+        this.eventQueue.push(event);
+        if (this.eventQueue.length >= (this.config.batchSize || 10)) {
+          this.flushBatch();
+        } else if (!this.batchTimer) {
+          this.batchTimer = setTimeout(() => {
+            this.flushBatch();
+          }, this.config.batchTimeout || 5e3);
+        }
+      }
+      mapSpanType(type) {
+        const typeMap = {
+          llm: "generation",
+          custom: "span",
+          chain: "span",
+          tool: "tool",
+          retrieval: "retrieval",
+          retriever: "retrieval",
+          agent: "agent",
+          embedding: "generation",
+          prompt: "span",
+          guardrail: "span",
+          evaluation: "span",
+          remediation: "span"
+        };
+        return typeMap[type] || "span";
+      }
+      traceToEvent(trace) {
+        return {
+          id: uuidv7(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "trace-create",
+          body: {
+            id: trace.id,
+            name: trace.name,
+            input: trace.input,
+            output: trace.output,
+            status: trace.status,
+            status_message: trace.errorMessage,
+            metadata: trace.metadata,
+            tags: trace.tags,
+            user_id: trace.userId,
+            session_id: trace.sessionId,
+            environment: this.config.environment,
+            start_time: trace.startTime,
+            end_time: trace.endTime,
+            duration_ns: trace.durationNs
+          }
+        };
+      }
+      buildTokenUsage(tokens) {
+        if (!tokens) return void 0;
+        return {
+          prompt_tokens: tokens.prompt,
+          completion_tokens: tokens.completion,
+          total_tokens: tokens.total,
+          cached_tokens: tokens.cached
+        };
+      }
+      spanToEvent(span) {
+        return {
+          id: uuidv7(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "span-create",
+          body: {
+            id: span.id,
+            trace_id: span.traceId,
+            parent_id: span.parentSpanId,
+            name: span.name,
+            type: this.mapSpanType(span.type),
+            start_time: span.startTime,
+            input: span.input,
+            model: span.modelName,
+            metadata: span.metadata,
+            tags: span.tags,
+            status: span.status
+          }
+        };
+      }
+      traceUpdateEvent(trace) {
+        return {
+          id: uuidv7(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "trace-update",
+          body: {
+            id: trace.id,
+            output: trace.output,
+            status: trace.status,
+            status_message: trace.errorMessage,
+            end_time: trace.endTime,
+            duration_ns: trace.durationNs
+          }
+        };
+      }
+      spanUpdateEvent(span) {
+        return {
+          id: uuidv7(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "span-update",
+          body: {
+            id: span.id,
+            trace_id: span.traceId,
+            output: span.output,
+            status: span.status,
+            status_message: span.errorMessage,
+            end_time: span.endTime,
+            duration_ns: span.durationNs,
+            token_usage: this.buildTokenUsage(span.tokens),
+            cost: span.cost
+          }
+        };
+      }
+      async flushBatch() {
+        if (this.batchTimer) {
+          clearTimeout(this.batchTimer);
+          this.batchTimer = null;
+        }
+        if (this.eventQueue.length === 0) return;
+        const events = [...this.eventQueue];
+        this.eventQueue = [];
+        const typePriority = {
+          "trace-create": 0,
+          "span-create": 1,
+          "span-update": 2,
+          "trace-update": 3
+        };
+        events.sort((a, b) => (typePriority[a.type] ?? 99) - (typePriority[b.type] ?? 99));
+        const maxRetries = this.config.maxRetries ?? 1;
+        const retryDelay = this.config.retryDelay ?? 2e3;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            await this.sendToApi("/v1/ingestion", { batch: events });
+            return;
+          } catch (error) {
+            if (attempt < maxRetries) {
+              const delay = retryDelay * 2 ** attempt;
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            } else {
+              if (this.config.onError) {
+                this.config.onError(error instanceof Error ? error : new Error(String(error)));
+              }
+              if (this.config.debug) {
+                console.error("Failed to send batch after retries:", error);
+              }
+            }
+          }
+        }
+      }
+      // ============================================================================
+      // API Communication
+      // ============================================================================
+      async sendToApi(endpoint, data) {
+        const response = await fetch(`${this.config.apiUrl}${endpoint}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": this.config.apiKey,
+            "X-Project-Name": this.config.projectName || ""
+          },
+          body: JSON.stringify(data)
+        });
+        if (!response.ok) {
+          throw new Error(`API error: ${response.status} ${response.statusText}`);
+        }
+        return response;
+      }
+      // ============================================================================
+      // Shutdown
+      // ============================================================================
+      /**
+       * Force flush all pending spans and signals immediately.
+       * Unlike shutdown(), this does not disable the client afterwards.
+       */
+      async forceFlush() {
+        await this.flushBatch();
+      }
+      async shutdown() {
+        await this.flushBatch();
+        this.disable();
+      }
+    };
+  }
+});
+
+// src/testing/jest.ts
+function wrapJest(testFn) {
+  return (name, fn, timeout) => {
+    testFn(
+      name,
+      async () => {
+        let client;
+        try {
+          const { getKyte: getKyte2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = getKyte2();
+        } catch {
+          return fn();
+        }
+        return client.trace(
+          `test: ${name}`,
+          async () => {
+            return fn();
+          },
+          { type: "custom", metadata: { testFramework: "jest" } }
+        );
+      },
+      timeout
+    );
+  };
+}
+
+// src/testing/vitest.ts
+function wrapVitest(testFn) {
+  return (name, fn, timeout) => {
+    testFn(
+      name,
+      async () => {
+        let client;
+        try {
+          const { getKyte: getKyte2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = getKyte2();
+        } catch {
+          return fn();
+        }
+        return client.trace(
+          `test: ${name}`,
+          async () => {
+            return fn();
+          },
+          { type: "custom", metadata: { testFramework: "vitest" } }
+        );
+      },
+      timeout
+    );
+  };
+}
+
+export { wrapJest, wrapVitest };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map