memorylens 0.1.0

package/dist/integrations/langchain/index.mjs

@@ -0,0 +1,237 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/tracer.ts
+import { randomUUID } from "crypto";
+
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var contextStorage = new AsyncLocalStorage();
+function getCurrentContext() {
+  return contextStorage.getStore();
+}
+
+// src/sampler.ts
+var Sampler = class {
+  rate;
+  constructor(rate = 1) {
+    if (rate < 0 || rate > 1) {
+      throw new Error(`Sample rate must be between 0.0 and 1.0, got ${rate}`);
+    }
+    this.rate = rate;
+  }
+  shouldSample() {
+    if (this.rate === 1) return true;
+    if (this.rate === 0) return false;
+    return Math.random() < this.rate;
+  }
+  getRate() {
+    return this.rate;
+  }
+};
+
+// src/tracer.ts
+var MutableSpan = class {
+  traceId;
+  spanId;
+  operation;
+  parentSpanId;
+  status = "ok";
+  startTime;
+  endTime = 0;
+  agentId;
+  sessionId;
+  userId;
+  inputContent = null;
+  outputContent = null;
+  attributes;
+  constructor(options) {
+    this.traceId = randomUUID().replace(/-/g, "");
+    this.spanId = randomUUID().replace(/-/g, "").substring(0, 16);
+    this.operation = options.operation;
+    this.parentSpanId = options.parentSpanId ?? null;
+    const ctx = getCurrentContext();
+    this.agentId = options.agentId !== void 0 ? options.agentId : ctx?.agentId ?? null;
+    this.sessionId = options.sessionId !== void 0 ? options.sessionId : ctx?.sessionId ?? null;
+    this.userId = options.userId !== void 0 ? options.userId : ctx?.userId ?? null;
+    this.attributes = { ...options.attributes };
+    this.startTime = Date.now();
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+  setContent(input, output) {
+    if (input !== void 0) this.inputContent = input;
+    if (output !== void 0) this.outputContent = output;
+  }
+  setStatus(status) {
+    this.status = status;
+  }
+  setError(error) {
+    this.status = "error";
+    if (error instanceof Error) {
+      this.attributes["error.type"] = error.constructor.name;
+      this.attributes["error.message"] = error.message;
+    } else {
+      this.attributes["error.type"] = "Error";
+      this.attributes["error.message"] = String(error);
+    }
+  }
+  end() {
+    this.endTime = Date.now();
+    return {
+      spanId: this.spanId,
+      traceId: this.traceId,
+      parentSpanId: this.parentSpanId,
+      operation: this.operation,
+      status: this.status,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      durationMs: this.endTime - this.startTime,
+      agentId: this.agentId,
+      sessionId: this.sessionId,
+      userId: this.userId,
+      inputContent: this.inputContent,
+      outputContent: this.outputContent,
+      attributes: { ...this.attributes }
+    };
+  }
+};
+var Tracer = class {
+  name;
+  provider;
+  constructor(name, provider) {
+    this.name = name;
+    this.provider = provider;
+  }
+  getName() {
+    return this.name;
+  }
+  startSpan(operation, attributes) {
+    const ctx = getCurrentContext();
+    return new MutableSpan({
+      operation,
+      agentId: ctx?.agentId ?? null,
+      sessionId: ctx?.sessionId ?? null,
+      userId: ctx?.userId ?? null,
+      attributes
+    });
+  }
+  endSpan(span) {
+    const finished = span.end();
+    for (const processor of this.provider.processors) {
+      processor.onEnd(finished);
+    }
+  }
+};
+var TracerProvider = class _TracerProvider {
+  static instance = null;
+  processors = [];
+  sampler = new Sampler(1);
+  serviceName = "memorylens";
+  static get() {
+    if (!_TracerProvider.instance) {
+      _TracerProvider.instance = new _TracerProvider();
+    }
+    return _TracerProvider.instance;
+  }
+  static reset() {
+    if (_TracerProvider.instance) {
+      for (const p of _TracerProvider.instance.processors) {
+        p.shutdown().catch(() => {
+        });
+      }
+    }
+    _TracerProvider.instance = null;
+  }
+  addProcessor(processor) {
+    this.processors.push(processor);
+  }
+  getTracer(name) {
+    return new Tracer(name, this);
+  }
+  async shutdown() {
+    for (const p of this.processors) {
+      await p.shutdown();
+    }
+  }
+};
+
+// src/integrations/langchain/instrumentor.ts
+var originals = /* @__PURE__ */ new WeakMap();
+var LangChainInstrumentor = class {
+  patched = false;
+  instrument(_options) {
+    if (this.patched) return;
+    let BaseChatMemory;
+    try {
+      const mod = __require("langchain/memory");
+      BaseChatMemory = mod.BaseChatMemory;
+    } catch {
+      console.warn("[memorylens] langchain/memory not found \u2014 LangChain instrumentation skipped");
+      return;
+    }
+    if (!BaseChatMemory?.prototype) return;
+    const proto = BaseChatMemory.prototype;
+    const origSaveContext = proto.saveContext;
+    const origLoadMemoryVariables = proto.loadMemoryVariables;
+    proto.saveContext = async function(...args) {
+      const provider = TracerProvider.get();
+      const tracer = provider.getTracer("memorylens.langchain");
+      const span = tracer.startSpan("memory.write", { "langchain.method": "saveContext" });
+      try {
+        const result = await origSaveContext.apply(this, args);
+        tracer.endSpan(span);
+        return result;
+      } catch (error) {
+        span.setError(error);
+        tracer.endSpan(span);
+        throw error;
+      }
+    };
+    proto.loadMemoryVariables = async function(...args) {
+      const provider = TracerProvider.get();
+      const tracer = provider.getTracer("memorylens.langchain");
+      const span = tracer.startSpan("memory.read", {
+        "langchain.method": "loadMemoryVariables"
+      });
+      try {
+        const result = await origLoadMemoryVariables.apply(this, args);
+        tracer.endSpan(span);
+        return result;
+      } catch (error) {
+        span.setError(error);
+        tracer.endSpan(span);
+        throw error;
+      }
+    };
+    originals.set(proto, { saveContext: origSaveContext, loadMemoryVariables: origLoadMemoryVariables });
+    this.patched = true;
+  }
+  uninstrument() {
+    if (!this.patched) return;
+    let BaseChatMemory;
+    try {
+      const mod = __require("langchain/memory");
+      BaseChatMemory = mod.BaseChatMemory;
+    } catch {
+      return;
+    }
+    if (!BaseChatMemory?.prototype) return;
+    const proto = BaseChatMemory.prototype;
+    const orig = originals.get(proto);
+    if (orig) {
+      proto.saveContext = orig.saveContext;
+      proto.loadMemoryVariables = orig.loadMemoryVariables;
+      originals.delete(proto);
+    }
+    this.patched = false;
+  }
+};
+export {
+  LangChainInstrumentor
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "memorylens",
+  "version": "0.1.0",
+  "description": "Observability and debugging for AI agent memory systems",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./integrations/langchain": {
+      "types": "./dist/integrations/langchain/index.d.ts",
+      "import": "./dist/integrations/langchain/index.js",
+      "require": "./dist/integrations/langchain/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@opentelemetry/api": "^1.7.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.48.0",
+    "@opentelemetry/sdk-trace-base": "^1.20.0"
+  },
+  "peerDependencies": {
+    "langchain": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "langchain": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  }
+}