@firstflow/core 0.0.6 → 0.0.9

package/dist/langchain.js

@@ -0,0 +1,1661 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/langchain.ts
+var langchain_exports = {};
+__export(langchain_exports, {
+  FirstflowCallbackHandler: () => FirstflowCallbackHandler,
+  firstflowCallback: () => firstflowCallback,
+  withFirstflow: () => withFirstflow
+});
+module.exports = __toCommonJS(langchain_exports);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/langchain.ts
+var import_base = require("@langchain/core/callbacks/base");
+
+// src/runtime.ts
+var import_sdk_node = require("@opentelemetry/sdk-node");
+var import_resources = require("@opentelemetry/resources");
+var import_instrumentation_openai = require("@opentelemetry/instrumentation-openai");
+var import_instrumentation_anthropic = require("@traceloop/instrumentation-anthropic");
+
+// node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION = "1.9.1";
+
+// node_modules/@opentelemetry/api/build/esm/internal/semver.js
+var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function _makeCompatibilityCheck(ownVersion) {
+  const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  const rejectedVersions = /* @__PURE__ */ new Set();
+  const myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return () => false;
+  }
+  const ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    const globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    const globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var isCompatible = _makeCompatibilityCheck(VERSION);
+
+// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+var major = VERSION.split(".")[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`);
+var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+function registerGlobal(type, instance, diag2, allowOverride = false) {
+  var _a;
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag2.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag2) {
+  diag2.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+
+// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+var DiagComponentLogger = class {
+  constructor(props) {
+    this._namespace = props.namespace || "DiagComponentLogger";
+  }
+  debug(...args) {
+    return logProxy("debug", this._namespace, args);
+  }
+  error(...args) {
+    return logProxy("error", this._namespace, args);
+  }
+  info(...args) {
+    return logProxy("info", this._namespace, args);
+  }
+  warn(...args) {
+    return logProxy("warn", this._namespace, args);
+  }
+  verbose(...args) {
+    return logProxy("verbose", this._namespace, args);
+  }
+};
+function logProxy(funcName, namespace, args) {
+  const logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  return logger[funcName](namespace, ...args);
+}
+
+// node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+(function(DiagLogLevel2) {
+  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+
+// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    const theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+
+// node_modules/@opentelemetry/api/build/esm/api/diag.js
+var API_NAME = "diag";
+var DiagAPI = class _DiagAPI {
+  /** Get the singleton instance of the DiagAPI API */
+  static instance() {
+    if (!this._instance) {
+      this._instance = new _DiagAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Private internal constructor
+   * @private
+   */
+  constructor() {
+    function _logProxy(funcName) {
+      return function(...args) {
+        const logger = getGlobal("diag");
+        if (!logger)
+          return;
+        return logger[funcName](...args);
+      };
+    }
+    const self2 = this;
+    const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+      var _a, _b, _c;
+      if (logger === self2) {
+        const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+        self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+        return false;
+      }
+      if (typeof optionsOrLogLevel === "number") {
+        optionsOrLogLevel = {
+          logLevel: optionsOrLogLevel
+        };
+      }
+      const oldLogger = getGlobal("diag");
+      const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+        const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+        oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+        newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+      }
+      return registerGlobal("diag", newLogger, self2, true);
+    };
+    self2.setLogger = setLogger;
+    self2.disable = () => {
+      unregisterGlobal(API_NAME, self2);
+    };
+    self2.createComponentLogger = (options) => {
+      return new DiagComponentLogger(options);
+    };
+    self2.verbose = _logProxy("verbose");
+    self2.debug = _logProxy("debug");
+    self2.info = _logProxy("info");
+    self2.warn = _logProxy("warn");
+    self2.error = _logProxy("error");
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
+var BaggageImpl = class _BaggageImpl {
+  constructor(entries) {
+    this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+  }
+  getEntry(key) {
+    const entry = this._entries.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    return Object.assign({}, entry);
+  }
+  getAllEntries() {
+    return Array.from(this._entries.entries());
+  }
+  setEntry(key, entry) {
+    const newBaggage = new _BaggageImpl(this._entries);
+    newBaggage._entries.set(key, entry);
+    return newBaggage;
+  }
+  removeEntry(key) {
+    const newBaggage = new _BaggageImpl(this._entries);
+    newBaggage._entries.delete(key);
+    return newBaggage;
+  }
+  removeEntries(...keys) {
+    const newBaggage = new _BaggageImpl(this._entries);
+    for (const key of keys) {
+      newBaggage._entries.delete(key);
+    }
+    return newBaggage;
+  }
+  clear() {
+    return new _BaggageImpl();
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/baggage/utils.js
+var diag = DiagAPI.instance();
+function createBaggage(entries = {}) {
+  return new BaggageImpl(new Map(Object.entries(entries)));
+}
+
+// node_modules/@opentelemetry/api/build/esm/context/context.js
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+var BaseContext = class _BaseContext {
+  /**
+   * Construct a new context which inherits values from an optional parent context.
+   *
+   * @param parentContext a context from which to inherit values
+   */
+  constructor(parentContext) {
+    const self2 = this;
+    self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+    self2.getValue = (key) => self2._currentContext.get(key);
+    self2.setValue = (key, value) => {
+      const context = new _BaseContext(self2._currentContext);
+      context._currentContext.set(key, value);
+      return context;
+    };
+    self2.deleteValue = (key) => {
+      const context = new _BaseContext(self2._currentContext);
+      context._currentContext.delete(key);
+      return context;
+    };
+  }
+};
+var ROOT_CONTEXT = new BaseContext();
+
+// node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
+var defaultTextMapGetter = {
+  get(carrier, key) {
+    if (carrier == null) {
+      return void 0;
+    }
+    return carrier[key];
+  },
+  keys(carrier) {
+    if (carrier == null) {
+      return [];
+    }
+    return Object.keys(carrier);
+  }
+};
+var defaultTextMapSetter = {
+  set(carrier, key, value) {
+    if (carrier == null) {
+      return;
+    }
+    carrier[key] = value;
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var NoopContextManager = class {
+  active() {
+    return ROOT_CONTEXT;
+  }
+  with(_context, fn, thisArg, ...args) {
+    return fn.call(thisArg, ...args);
+  }
+  bind(_context, target) {
+    return target;
+  }
+  enable() {
+    return this;
+  }
+  disable() {
+    return this;
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/api/context.js
+var API_NAME2 = "context";
+var NOOP_CONTEXT_MANAGER = new NoopContextManager();
+var ContextAPI = class _ContextAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+  }
+  /** Get the singleton instance of the Context API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ContextAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current context manager.
+   *
+   * @returns true if the context manager was successfully registered, else false
+   */
+  setGlobalContextManager(contextManager) {
+    return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+  }
+  /**
+   * Get the currently active context
+   */
+  active() {
+    return this._getContextManager().active();
+  }
+  /**
+   * Execute a function with an active context
+   *
+   * @param context context to be active during function execution
+   * @param fn function to execute in a context
+   * @param thisArg optional receiver to be used for calling fn
+   * @param args optional arguments forwarded to fn
+   */
+  with(context, fn, thisArg, ...args) {
+    return this._getContextManager().with(context, fn, thisArg, ...args);
+  }
+  /**
+   * Bind a context to a target function or event emitter
+   *
+   * @param context context to bind to the event emitter or function. Defaults to the currently active context
+   * @param target function or event emitter to bind
+   */
+  bind(context, target) {
+    return this._getContextManager().bind(context, target);
+  }
+  _getContextManager() {
+    return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+  }
+  /** Disable and remove the global context manager */
+  disable() {
+    this._getContextManager().disable();
+    unregisterGlobal(API_NAME2, DiagAPI.instance());
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
+var NoopTextMapPropagator = class {
+  /** Noop inject function does nothing */
+  inject(_context, _carrier) {
+  }
+  /** Noop extract function does nothing and returns the input context */
+  extract(context, _carrier) {
+    return context;
+  }
+  fields() {
+    return [];
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
+var BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+function getBaggage(context) {
+  return context.getValue(BAGGAGE_KEY) || void 0;
+}
+function getActiveBaggage() {
+  return getBaggage(ContextAPI.getInstance().active());
+}
+function setBaggage(context, baggage) {
+  return context.setValue(BAGGAGE_KEY, baggage);
+}
+function deleteBaggage(context) {
+  return context.deleteValue(BAGGAGE_KEY);
+}
+
+// node_modules/@opentelemetry/api/build/esm/api/propagation.js
+var API_NAME3 = "propagation";
+var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+var PropagationAPI = class _PropagationAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+    this.createBaggage = createBaggage;
+    this.getBaggage = getBaggage;
+    this.getActiveBaggage = getActiveBaggage;
+    this.setBaggage = setBaggage;
+    this.deleteBaggage = deleteBaggage;
+  }
+  /** Get the singleton instance of the Propagator API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _PropagationAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current propagator.
+   *
+   * @returns true if the propagator was successfully registered, else false
+   */
+  setGlobalPropagator(propagator) {
+    return registerGlobal(API_NAME3, propagator, DiagAPI.instance());
+  }
+  /**
+   * Inject context into a carrier to be propagated inter-process
+   *
+   * @param context Context carrying tracing data to inject
+   * @param carrier carrier to inject context into
+   * @param setter Function used to set values on the carrier
+   */
+  inject(context, carrier, setter = defaultTextMapSetter) {
+    return this._getGlobalPropagator().inject(context, carrier, setter);
+  }
+  /**
+   * Extract context from a carrier
+   *
+   * @param context Context which the newly created context will inherit from
+   * @param carrier Carrier to extract context from
+   * @param getter Function used to extract keys from a carrier
+   */
+  extract(context, carrier, getter = defaultTextMapGetter) {
+    return this._getGlobalPropagator().extract(context, carrier, getter);
+  }
+  /**
+   * Return a list of all fields which may be used by the propagator.
+   */
+  fields() {
+    return this._getGlobalPropagator().fields();
+  }
+  /** Remove the global propagator */
+  disable() {
+    unregisterGlobal(API_NAME3, DiagAPI.instance());
+  }
+  _getGlobalPropagator() {
+    return getGlobal(API_NAME3) || NOOP_TEXT_MAP_PROPAGATOR;
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/propagation-api.js
+var propagation = PropagationAPI.getInstance();
+
+// src/firstflow-span-processor.ts
+var FLUSH_SIZE = 20;
+var FLUSH_INTERVAL_MS = 2e3;
+var REQUEST_TIMEOUT_MS = 1e4;
+var MAX_QUEUE_SIZE = 500;
+var AGENT_ID_ATTR = "firstflow.agent_id";
+function spanToOtlpJson(span) {
+  const attrs = span.attributes;
+  const otlpAttrs = [];
+  for (const [key, val] of Object.entries(attrs)) {
+    if (val === void 0) continue;
+    if (key === AGENT_ID_ATTR) continue;
+    if (typeof val === "string") {
+      otlpAttrs.push({ key, value: { stringValue: val } });
+    } else if (typeof val === "number") {
+      if (Number.isInteger(val)) {
+        otlpAttrs.push({ key, value: { intValue: val } });
+      } else {
+        otlpAttrs.push({ key, value: { doubleValue: val } });
+      }
+    } else if (typeof val === "boolean") {
+      otlpAttrs.push({ key, value: { boolValue: val } });
+    }
+  }
+  const startNs = BigInt(span.startTime[0]) * BigInt(1e9) + BigInt(span.startTime[1]);
+  const endNs = BigInt(span.endTime[0]) * BigInt(1e9) + BigInt(span.endTime[1]);
+  const parentId = span.parentSpanId;
+  return {
+    traceId: span.spanContext().traceId,
+    spanId: span.spanContext().spanId,
+    parentSpanId: parentId || void 0,
+    name: span.name,
+    startTimeUnixNano: startNs.toString(),
+    endTimeUnixNano: endNs.toString(),
+    status: span.status ? { code: span.status.code, message: span.status.message } : void 0,
+    attributes: otlpAttrs
+  };
+}
+var FirstflowSpanProcessor = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  /** Spans partitioned by agent id — partitioning happens at ingest, not flush. */
+  buffers = /* @__PURE__ */ new Map();
+  bufferedCount = 0;
+  flushTimer;
+  onStart(span, parentContext) {
+    const agentId = propagation.getBaggage(parentContext)?.getEntry(AGENT_ID_ATTR)?.value;
+    if (agentId) span.setAttribute(AGENT_ID_ATTR, agentId);
+  }
+  onEnd(span) {
+    const genAi = span.attributes["gen_ai.system"];
+    if (!genAi) return;
+    const agentId = span.attributes[AGENT_ID_ATTR];
+    if (typeof agentId !== "string" || !agentId) return;
+    let bucket = this.buffers.get(agentId);
+    if (!bucket) {
+      bucket = [];
+      this.buffers.set(agentId, bucket);
+    }
+    if (this.bufferedCount >= MAX_QUEUE_SIZE) {
+      const firstKey = this.buffers.keys().next().value;
+      if (firstKey !== void 0) {
+        const b = this.buffers.get(firstKey);
+        b.shift();
+        if (b.length === 0) this.buffers.delete(firstKey);
+        this.bufferedCount--;
+      }
+    }
+    bucket.push(span);
+    this.bufferedCount++;
+    if (this.bufferedCount >= FLUSH_SIZE) {
+      void this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  async shutdown() {
+    if (this.flushTimer != null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    await this.flush();
+  }
+  async forceFlush() {
+    await this.flush();
+  }
+  scheduleFlush() {
+    if (this.flushTimer != null) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      void this.flush();
+    }, FLUSH_INTERVAL_MS);
+  }
+  async flush() {
+    if (this.flushTimer != null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    if (this.bufferedCount === 0) return;
+    const batches = [...this.buffers.entries()];
+    this.buffers.clear();
+    this.bufferedCount = 0;
+    await Promise.all(batches.map(([agentId, spans]) => this.post(agentId, spans)));
+  }
+  async post(agentId, spans) {
+    if (spans.length === 0) return;
+    const otlpSpans = spans.map(spanToOtlpJson);
+    const body = JSON.stringify({
+      resourceSpans: [
+        {
+          resource: {
+            attributes: [
+              { key: "service.name", value: { stringValue: "firstflow-server" } }
+            ]
+          },
+          scopeSpans: [{ spans: otlpSpans }]
+        }
+      ]
+    });
+    const url = `${this.opts.baseUrl}/v1/agents/${encodeURIComponent(agentId)}/traces`;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.opts.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        signal: ac.signal
+      });
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/sanitize.ts
+var SENSITIVE_KEY_RE = /(password|secret|token|api[-_]?key|cookie|auth)/i;
+var DEFAULT_MAX_DEPTH = 4;
+var DEFAULT_MAX_STRING_LEN = 1024;
+var RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "token",
+  "api_key",
+  "distinct_id",
+  "$anon_distinct_id",
+  "$device_id",
+  "$session_id",
+  "$user_id",
+  "$set",
+  "$set_once",
+  "groups",
+  "$groups",
+  "event",
+  "timestamp",
+  "$insert_id",
+  "$lib",
+  "$lib_version",
+  "$current_url",
+  "$host",
+  "$pathname",
+  "$referrer",
+  "$referring_domain"
+]);
+function isReservedKey(key) {
+  return RESERVED_KEYS.has(key) || key.startsWith("$");
+}
+function sanitizeValueInternal(value, depth, maxDepth, maxStringLen) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    if (value.length <= maxStringLen) return value;
+    return `${value.slice(0, maxStringLen)}\u2026truncated`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value !== "object") return void 0;
+  if (depth >= maxDepth) return void 0;
+  if (Array.isArray(value)) {
+    const next = [];
+    for (const entry of value) {
+      next.push(sanitizeValueInternal(entry, depth + 1, maxDepth, maxStringLen));
+    }
+    return next;
+  }
+  const obj = value;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const keyStr = String(k);
+    if (!isReservedKey(keyStr) && SENSITIVE_KEY_RE.test(keyStr)) continue;
+    const sv = sanitizeValueInternal(v, depth + 1, maxDepth, maxStringLen);
+    if (sv !== void 0) out[keyStr] = sv;
+  }
+  return Object.keys(out).length > 0 ? out : {};
+}
+function sanitizeAnalyticsProperties(properties, opts = {}) {
+  try {
+    const maxDepth = typeof opts.maxDepth === "number" && opts.maxDepth >= 1 ? opts.maxDepth : DEFAULT_MAX_DEPTH;
+    const maxStringLen = typeof opts.maxStringLen === "number" && opts.maxStringLen >= 1 ? opts.maxStringLen : DEFAULT_MAX_STRING_LEN;
+    const sanitized = sanitizeValueInternal(properties, 0, maxDepth, maxStringLen);
+    return sanitized && typeof sanitized === "object" && !Array.isArray(sanitized) ? sanitized : {};
+  } catch {
+    return {};
+  }
+}
+
+// src/analytics-client.ts
+var FLUSH_SIZE2 = 20;
+var FLUSH_INTERVAL_MS2 = 1e3;
+var MAX_QUEUE_SIZE2 = 1e3;
+var REQUEST_TIMEOUT_MS2 = 5e3;
+var MAX_BACKOFF_MS = 8e3;
+var FirstflowAnalyticsClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  buffer = [];
+  flushTimer;
+  backoffMs = 1e3;
+  closed = false;
+  track(userId, event, properties) {
+    if (this.closed) return;
+    this.enqueue({
+      event,
+      message_id: crypto.randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      session_id: "",
+      anonymous_id: "",
+      user_id: userId,
+      sdk_version: this.opts.sdkVersion,
+      ...properties && Object.keys(properties).length > 0 ? { props: sanitizeAnalyticsProperties(properties) } : {}
+    });
+  }
+  identify(userId, traits) {
+    if (this.closed) return;
+    this.enqueue({
+      event: "user_identified",
+      message_id: crypto.randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      session_id: "",
+      anonymous_id: "",
+      user_id: userId,
+      sdk_version: this.opts.sdkVersion,
+      ...traits && Object.keys(traits).length > 0 ? { props: sanitizeAnalyticsProperties(traits) } : {}
+    });
+  }
+  async shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.flushTimer != null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    await this.flush();
+  }
+  enqueue(event) {
+    if (this.buffer.length >= MAX_QUEUE_SIZE2) {
+      this.buffer.shift();
+    }
+    this.buffer.push(event);
+    if (this.buffer.length >= FLUSH_SIZE2) {
+      void this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  scheduleFlush() {
+    if (this.flushTimer != null) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      void this.flush();
+    }, FLUSH_INTERVAL_MS2);
+  }
+  async flush() {
+    if (this.flushTimer != null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0, this.buffer.length);
+    const url = `${this.opts.baseUrl}/agents/${encodeURIComponent(this.opts.agentId)}/analytics/events`;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), REQUEST_TIMEOUT_MS2);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.opts.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ events: batch }),
+        signal: ac.signal
+      });
+      if (res.ok) {
+        this.backoffMs = 1e3;
+      } else {
+        this.requeueWithBackoff(batch);
+      }
+    } catch {
+      this.requeueWithBackoff(batch);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  requeueWithBackoff(events) {
+    if (this.closed) return;
+    const space = MAX_QUEUE_SIZE2 - this.buffer.length;
+    if (space > 0) {
+      this.buffer.unshift(...events.slice(0, space));
+    }
+    const wait = Math.min(this.backoffMs, MAX_BACKOFF_MS);
+    this.backoffMs = Math.min(this.backoffMs * 2, MAX_BACKOFF_MS);
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      void this.flush();
+    }, wait);
+  }
+};
+
+// src/llm-content-redactor.ts
+function stripGenAiContentAttributes(attrs) {
+  if (!attrs) return attrs;
+  const out = { ...attrs };
+  for (const key of Object.keys(out)) {
+    if (key.startsWith("gen_ai.prompt") || key.startsWith("gen_ai.completion") || key.startsWith("gen_ai.input.") || key.startsWith("gen_ai.output.")) {
+      delete out[key];
+    }
+  }
+  return out;
+}
+function withRedactedAttributes(span) {
+  return new Proxy(span, {
+    get(target, prop, receiver) {
+      if (prop === "attributes") {
+        const raw = Reflect.get(target, "attributes", receiver);
+        return stripGenAiContentAttributes(raw) ?? raw;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function createLlmContentRedactor(captureLlmContent, inner) {
+  return {
+    onStart(span, parentContext) {
+      inner.onStart(span, parentContext);
+    },
+    onEnd(span) {
+      if (captureLlmContent) {
+        inner.onEnd(span);
+        return;
+      }
+      inner.onEnd(withRedactedAttributes(span));
+    },
+    shutdown() {
+      return inner.shutdown();
+    },
+    forceFlush() {
+      return inner.forceFlush();
+    }
+  };
+}
+
+// src/forwarder.ts
+var FORWARD_TIMEOUT_MS = 2e3;
+function forwardConversationMessage(args, failureBuffer) {
+  const url = `${args.baseUrl.replace(/\/$/, "")}/v1/conversations/${encodeURIComponent(
+    args.conversationId
+  )}/messages`;
+  const body = JSON.stringify({
+    agentId: args.agentId,
+    conversationId: args.conversationId,
+    userId: args.userId,
+    role: args.role,
+    content: args.content,
+    ...args.recentMessages && args.recentMessages.length ? { recentMessages: args.recentMessages } : {},
+    ...args.model !== void 0 ? { model: args.model } : {},
+    ...args.provider !== void 0 ? { provider: args.provider } : {},
+    ...args.inputTokens !== void 0 ? { inputTokens: args.inputTokens } : {},
+    ...args.outputTokens !== void 0 ? { outputTokens: args.outputTokens } : {},
+    ...args.cacheReadTokens !== void 0 ? { cacheReadTokens: args.cacheReadTokens } : {},
+    ...args.cacheCreationTokens !== void 0 ? { cacheCreationTokens: args.cacheCreationTokens } : {},
+    ...args.latencyMs !== void 0 ? { latencyMs: args.latencyMs } : {},
+    ...args.timeToFirstTokenMs !== void 0 ? { timeToFirstTokenMs: args.timeToFirstTokenMs } : {},
+    ...args.finishReason !== void 0 ? { finishReason: args.finishReason } : {},
+    ...args.isError !== void 0 ? { isError: args.isError } : {},
+    ...args.error !== void 0 ? { error: args.error } : {},
+    ...args.inputCostUsd !== void 0 ? { inputCostUsd: args.inputCostUsd } : {},
+    ...args.outputCostUsd !== void 0 ? { outputCostUsd: args.outputCostUsd } : {},
+    ...args.totalCostUsd !== void 0 ? { totalCostUsd: args.totalCostUsd } : {},
+    ...args.httpStatus !== void 0 ? { httpStatus: args.httpStatus } : {},
+    ...args.properties !== void 0 ? { properties: args.properties } : {}
+  });
+  void (async () => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), FORWARD_TIMEOUT_MS);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${args.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        signal: ac.signal
+      });
+      if (!res.ok) {
+        failureBuffer?.push(args);
+      }
+    } catch {
+      failureBuffer?.push(args);
+    } finally {
+      clearTimeout(timer);
+    }
+  })();
+}
+
+// src/trace-forwarder.ts
+var TRACE_FORWARD_TIMEOUT_MS = 2e3;
+function toIso(d) {
+  if (d === void 0 || d === null) return void 0;
+  return d instanceof Date ? d.toISOString() : d;
+}
+function serializeSpan(s) {
+  return {
+    ...s.spanId !== void 0 ? { spanId: s.spanId } : {},
+    ...s.parentSpanId !== void 0 ? { parentSpanId: s.parentSpanId } : {},
+    ...s.type !== void 0 ? { type: s.type } : {},
+    ...s.name !== void 0 ? { name: s.name } : {},
+    ...s.model !== void 0 ? { model: s.model } : {},
+    ...s.provider !== void 0 ? { provider: s.provider } : {},
+    ...s.input !== void 0 ? { input: s.input } : {},
+    ...s.output !== void 0 ? { output: s.output } : {},
+    ...s.inputTokens !== void 0 ? { inputTokens: s.inputTokens } : {},
+    ...s.outputTokens !== void 0 ? { outputTokens: s.outputTokens } : {},
+    ...s.cacheReadTokens !== void 0 ? { cacheReadTokens: s.cacheReadTokens } : {},
+    ...s.cacheCreationTokens !== void 0 ? { cacheCreationTokens: s.cacheCreationTokens } : {},
+    ...s.latencyMs !== void 0 ? { latencyMs: s.latencyMs } : {},
+    ...s.timeToFirstTokenMs !== void 0 ? { timeToFirstTokenMs: s.timeToFirstTokenMs } : {},
+    ...s.finishReason !== void 0 ? { finishReason: s.finishReason } : {},
+    ...s.isError !== void 0 ? { isError: s.isError } : {},
+    ...s.error !== void 0 ? { error: s.error } : {},
+    ...s.inputCostUsd !== void 0 ? { inputCostUsd: s.inputCostUsd } : {},
+    ...s.outputCostUsd !== void 0 ? { outputCostUsd: s.outputCostUsd } : {},
+    ...s.totalCostUsd !== void 0 ? { totalCostUsd: s.totalCostUsd } : {},
+    ...s.toolsCalled !== void 0 ? { toolsCalled: s.toolsCalled } : {},
+    ...s.toolCallCount !== void 0 ? { toolCallCount: s.toolCallCount } : {},
+    ...s.inputState !== void 0 ? { inputState: s.inputState } : {},
+    ...s.outputState !== void 0 ? { outputState: s.outputState } : {},
+    ...s.httpStatus !== void 0 ? { httpStatus: s.httpStatus } : {},
+    ...s.properties !== void 0 ? { properties: s.properties } : {},
+    ...s.startedAt !== void 0 ? { startedAt: toIso(s.startedAt) } : {},
+    ...s.endedAt !== void 0 ? { endedAt: toIso(s.endedAt) } : {}
+  };
+}
+function serializeTrace(t) {
+  return {
+    ...t.traceId !== void 0 ? { traceId: t.traceId } : {},
+    ...t.sessionId !== void 0 ? { sessionId: t.sessionId } : {},
+    ...t.userId !== void 0 ? { userId: t.userId } : {},
+    ...t.name !== void 0 ? { name: t.name } : {},
+    ...t.inputState !== void 0 ? { inputState: t.inputState } : {},
+    ...t.outputState !== void 0 ? { outputState: t.outputState } : {},
+    ...t.latencyMs !== void 0 ? { latencyMs: t.latencyMs } : {},
+    ...t.isError !== void 0 ? { isError: t.isError } : {},
+    ...t.error !== void 0 ? { error: t.error } : {},
+    ...t.properties !== void 0 ? { properties: t.properties } : {},
+    ...t.startedAt !== void 0 ? { startedAt: toIso(t.startedAt) } : {},
+    ...t.endedAt !== void 0 ? { endedAt: toIso(t.endedAt) } : {},
+    ...t.spans && t.spans.length > 0 ? { spans: t.spans.map(serializeSpan) } : {}
+  };
+}
+function forwardTrace(args) {
+  const url = `${args.baseUrl.replace(/\/$/, "")}/v1/agents/${encodeURIComponent(args.agentId)}/traces`;
+  const body = JSON.stringify(serializeTrace(args.trace));
+  void (async () => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), TRACE_FORWARD_TIMEOUT_MS);
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${args.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        signal: ac.signal
+      });
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+  })();
+}
+
+// src/outcome-forwarder.ts
+var OUTCOME_FORWARD_TIMEOUT_MS = 2e3;
+function forwardOutcome(args) {
+  const url = `${args.baseUrl.replace(/\/$/, "")}/v1/conversations/${encodeURIComponent(args.conversationId)}/signal`;
+  const payload = {};
+  if (args.outcome !== void 0) payload.outcome = args.outcome;
+  if (args.intent !== void 0) payload.intent = args.intent;
+  if (args.userId !== void 0) payload.userId = args.userId;
+  const body = JSON.stringify(payload);
+  void (async () => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), OUTCOME_FORWARD_TIMEOUT_MS);
+    try {
+      await fetch(url, {
+        method: "PATCH",
+        headers: {
+          Authorization: `Bearer ${args.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        signal: ac.signal
+      });
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+  })();
+}
+
+// src/feedback-forwarder.ts
+var FEEDBACK_FORWARD_TIMEOUT_MS = 2e3;
+function forwardFeedback(args) {
+  const url = `${args.baseUrl.replace(/\/$/, "")}/v1/conversations/${encodeURIComponent(args.conversationId)}/feedback`;
+  const payload = { rating: args.rating };
+  if (args.comment !== void 0) payload.comment = args.comment;
+  if (args.messageId !== void 0) payload.messageId = args.messageId;
+  if (args.userId !== void 0) payload.userId = args.userId;
+  const body = JSON.stringify(payload);
+  void (async () => {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), FEEDBACK_FORWARD_TIMEOUT_MS);
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${args.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        signal: ac.signal
+      });
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+  })();
+}
+
+// src/ring-buffer.ts
+var DEFAULT_MAX = 1e3;
+var RingBuffer = class {
+  items = [];
+  max;
+  constructor(maxSize = DEFAULT_MAX) {
+    this.max = maxSize;
+  }
+  push(item) {
+    if (this.items.length >= this.max) {
+      this.items.shift();
+      if (typeof console !== "undefined" && typeof console.warn === "function") {
+        console.warn("[@firstflow/core] ring buffer overflow \u2014 dropped oldest entry");
+      }
+    }
+    this.items.push(item);
+  }
+  drainAll() {
+    const out = this.items.slice();
+    this.items.length = 0;
+    return out;
+  }
+  size() {
+    return this.items.length;
+  }
+};
+
+// src/model-pricing.ts
+var PRICING = {
+  // -------------------------------------------------------------------------
+  // OpenAI
+  // -------------------------------------------------------------------------
+  "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10 },
+  "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6 },
+  "gpt-4o-audio-preview": { inputPer1M: 2.5, outputPer1M: 10 },
+  "gpt-4-turbo": { inputPer1M: 10, outputPer1M: 30 },
+  "gpt-4": { inputPer1M: 30, outputPer1M: 60 },
+  "gpt-3.5-turbo": { inputPer1M: 0.5, outputPer1M: 1.5 },
+  "o1": { inputPer1M: 15, outputPer1M: 60 },
+  "o1-mini": { inputPer1M: 1.1, outputPer1M: 4.4 },
+  "o1-preview": { inputPer1M: 15, outputPer1M: 60 },
+  "o3": { inputPer1M: 10, outputPer1M: 40 },
+  "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4 },
+  "o4-mini": { inputPer1M: 1.1, outputPer1M: 4.4 },
+  // -------------------------------------------------------------------------
+  // Anthropic
+  // -------------------------------------------------------------------------
+  "claude-opus-4-5": { inputPer1M: 15, outputPer1M: 75 },
+  "claude-opus-4-7": { inputPer1M: 15, outputPer1M: 75 },
+  "claude-sonnet-4-5": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-haiku-4-5": { inputPer1M: 0.8, outputPer1M: 4 },
+  "claude-3-5-sonnet-20241022": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-3-5-sonnet-20240620": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-3-5-haiku-20241022": { inputPer1M: 0.8, outputPer1M: 4 },
+  "claude-3-opus-20240229": { inputPer1M: 15, outputPer1M: 75 },
+  "claude-3-sonnet-20240229": { inputPer1M: 3, outputPer1M: 15 },
+  "claude-3-haiku-20240307": { inputPer1M: 0.25, outputPer1M: 1.25 }
+};
+function findByPrefix(model) {
+  let candidate = model;
+  while (candidate.includes("-")) {
+    candidate = candidate.replace(/-[^-]+$/, "");
+    const match = Object.keys(PRICING).find((k) => k.startsWith(candidate));
+    if (match) return PRICING[match];
+  }
+  return void 0;
+}
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = PRICING[model] ?? findByPrefix(model);
+  if (!pricing) return null;
+  const inputCostUsd = inputTokens / 1e6 * pricing.inputPer1M;
+  const outputCostUsd = outputTokens / 1e6 * pricing.outputPer1M;
+  return { inputCostUsd, outputCostUsd, totalCostUsd: inputCostUsd + outputCostUsd };
+}
+
+// src/constants.ts
+var DEFAULT_FIRSTFLOW_BASE_URL = "https://api.firstflow.app";
+var FIRSTFLOW_SERVER_PACKAGE_VERSION = "0.0.1-alpha.0";
+
+// src/peer-deps.ts
+var import_node_module = require("module");
+var nodeRequire = (0, import_node_module.createRequire)(importMetaUrl);
+function requirePeer(moduleName) {
+  return nodeRequire(moduleName);
+}
+function isPeerPreloaded(moduleName) {
+  try {
+    const resolved = nodeRequire.resolve(moduleName);
+    const cached = nodeRequire.cache?.[resolved];
+    return cached !== void 0 && cached.exports !== void 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/runtime.ts
+function enrichSpanCosts(span) {
+  if (span.inputCostUsd !== void 0 && span.outputCostUsd !== void 0) return span;
+  if (!span.model || typeof span.inputTokens !== "number" || typeof span.outputTokens !== "number") {
+    return span;
+  }
+  const cost = calculateCost(span.model, span.inputTokens, span.outputTokens);
+  if (!cost) return span;
+  return {
+    ...span,
+    inputCostUsd: span.inputCostUsd ?? cost.inputCostUsd,
+    outputCostUsd: span.outputCostUsd ?? cost.outputCostUsd,
+    totalCostUsd: span.totalCostUsd ?? cost.totalCostUsd
+  };
+}
+function readCaptureLlmContent() {
+  return process.env.FIRSTFLOW_CAPTURE_LLM_CONTENT?.trim().toLowerCase() === "true";
+}
+var Runtime = class {
+  apiKey;
+  baseUrl;
+  forwardFailures = new RingBuffer(1e3);
+  analyticsByAgent = /* @__PURE__ */ new Map();
+  otelSdk;
+  closed = false;
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.startOpenTelemetry();
+    process.once("beforeExit", () => {
+      void this.shutdown();
+    });
+  }
+  startOpenTelemetry() {
+    const captureLlmContent = readCaptureLlmContent();
+    const inner = new FirstflowSpanProcessor({ apiKey: this.apiKey, baseUrl: this.baseUrl });
+    const chain = createLlmContentRedactor(captureLlmContent, inner);
+    const resource = (0, import_resources.resourceFromAttributes)({ "service.name": "firstflow-server" });
+    const anthropicInstrumentation = new import_instrumentation_anthropic.AnthropicInstrumentation({ traceContent: captureLlmContent });
+    const anthropicPreloaded = isPeerPreloaded("@anthropic-ai/sdk");
+    this.otelSdk = new import_sdk_node.NodeSDK({
+      resource,
+      spanProcessors: [chain],
+      instrumentations: [
+        new import_instrumentation_openai.OpenAIInstrumentation({ captureMessageContent: captureLlmContent }),
+        anthropicInstrumentation
+      ]
+    });
+    this.otelSdk.start();
+    if (anthropicPreloaded) {
+      try {
+        anthropicInstrumentation.manuallyInstrument(requirePeer("@anthropic-ai/sdk"));
+      } catch {
+      }
+    }
+  }
+  analyticsFor(agentId) {
+    let client = this.analyticsByAgent.get(agentId);
+    if (!client) {
+      client = new FirstflowAnalyticsClient({
+        apiKey: this.apiKey,
+        baseUrl: this.baseUrl,
+        agentId,
+        sdkVersion: FIRSTFLOW_SERVER_PACKAGE_VERSION
+      });
+      this.analyticsByAgent.set(agentId, client);
+    }
+    return client;
+  }
+  /**
+   * Build a request-agnostic `WrapContext` for the proxy. The context carries
+   * only infrastructure hooks — the per-request agent/user/session are parsed
+   * from each call and flow through `ObserveArgs`, never stored here.
+   */
+  wrapContext() {
+    return {
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      onAssistantComplete: (a) => this.observe(a),
+      onUserMessage: (a) => this.observe(a),
+      onError: (a) => {
+        if (!a.conversationId) return;
+        this.observe({
+          agentId: a.agentId,
+          conversationId: a.conversationId,
+          userId: a.userId,
+          role: "assistant",
+          content: "",
+          isError: true,
+          error: a.error,
+          model: a.model,
+          provider: a.provider,
+          latencyMs: a.latencyMs,
+          httpStatus: a.httpStatus
+        });
+      }
+    };
+  }
+  observe(args) {
+    let { inputCostUsd, outputCostUsd, totalCostUsd } = args;
+    if (totalCostUsd === void 0 && args.model && typeof args.inputTokens === "number" && typeof args.outputTokens === "number") {
+      const cost = calculateCost(args.model, args.inputTokens, args.outputTokens);
+      if (cost) {
+        inputCostUsd = cost.inputCostUsd;
+        outputCostUsd = cost.outputCostUsd;
+        totalCostUsd = cost.totalCostUsd;
+      }
+    }
+    forwardConversationMessage(
+      {
+        baseUrl: this.baseUrl,
+        apiKey: this.apiKey,
+        agentId: args.agentId,
+        conversationId: args.conversationId,
+        userId: args.userId,
+        role: args.role,
+        content: args.content,
+        model: args.model,
+        provider: args.provider,
+        inputTokens: args.inputTokens,
+        outputTokens: args.outputTokens,
+        cacheReadTokens: args.cacheReadTokens,
+        cacheCreationTokens: args.cacheCreationTokens,
+        latencyMs: args.latencyMs,
+        timeToFirstTokenMs: args.timeToFirstTokenMs,
+        finishReason: args.finishReason,
+        isError: args.isError,
+        error: args.error,
+        inputCostUsd,
+        outputCostUsd,
+        totalCostUsd,
+        httpStatus: args.httpStatus,
+        ...args.recentMessages ? { recentMessages: args.recentMessages } : {},
+        ...args.properties ? { properties: args.properties } : {}
+      },
+      this.forwardFailures
+    );
+    this.analyticsFor(args.agentId).track(args.userId, "conversation_message", {
+      conversation_id: args.conversationId,
+      role: args.role,
+      has_content: args.content.length > 0
+    });
+  }
+  trace(agentId, input) {
+    const enriched = input.spans ? { ...input, spans: input.spans.map(enrichSpanCosts) } : input;
+    forwardTrace({ baseUrl: this.baseUrl, apiKey: this.apiKey, agentId, trace: enriched });
+  }
+  outcome(args) {
+    forwardOutcome({ baseUrl: this.baseUrl, apiKey: this.apiKey, ...args });
+  }
+  feedback(args) {
+    forwardFeedback({ baseUrl: this.baseUrl, apiKey: this.apiKey, ...args });
+  }
+  track(agentId, userId, event, properties) {
+    this.analyticsFor(agentId).track(
+      userId,
+      event,
+      properties ? sanitizeAnalyticsProperties({ ...properties }) : void 0
+    );
+  }
+  identify(agentId, userId, traits) {
+    this.analyticsFor(agentId).identify(
+      userId,
+      traits ? sanitizeAnalyticsProperties({ ...traits }) : void 0
+    );
+  }
+  async shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.otelSdk) {
+      await this.otelSdk.shutdown().catch(() => {
+      });
+      this.otelSdk = void 0;
+    }
+    for (const client of this.analyticsByAgent.values()) {
+      await client.shutdown().catch(() => {
+      });
+    }
+    this.analyticsByAgent.clear();
+    const pending = this.forwardFailures.drainAll();
+    for (const p of pending) forwardConversationMessage(p, void 0);
+  }
+};
+var _runtime;
+function getRuntime() {
+  if (_runtime) return _runtime;
+  const apiKey = (process.env.FIRSTFLOW_API_KEY ?? "").trim();
+  if (!apiKey) {
+    throw new Error(
+      "[Firstflow] FIRSTFLOW_API_KEY is required. Set it in your server environment."
+    );
+  }
+  const baseUrl = (process.env.FIRSTFLOW_API_BASE_URL ?? DEFAULT_FIRSTFLOW_BASE_URL).replace(/\/$/, "");
+  _runtime = new Runtime(apiKey, baseUrl);
+  return _runtime;
+}
+
+// src/langchain.ts
+function asString(v) {
+  return typeof v === "string" ? v.trim() : "";
+}
+var warnedIncompleteTagging = false;
+function warnIncompleteOnce() {
+  if (warnedIncompleteTagging) return;
+  warnedIncompleteTagging = true;
+  console.warn(
+    "[@firstflow/core/langchain] A LangChain run was tagged with some but not all of `firstflowAgentId`, `sessionId`, `userId` \u2014 the turn was NOT observed. Provide all three in the run metadata to track it."
+  );
+}
+function readIdentity(metadata) {
+  if (!metadata) return void 0;
+  const nested = typeof metadata.firstflow === "object" && metadata.firstflow !== null ? metadata.firstflow : {};
+  const agentId = asString(metadata.firstflowAgentId ?? nested.agentId);
+  const sessionId = asString(metadata.sessionId ?? nested.sessionId);
+  const userId = asString(metadata.userId ?? nested.userId);
+  if (!agentId && !sessionId && !userId) return void 0;
+  if (!agentId || !sessionId || !userId) {
+    warnIncompleteOnce();
+    return void 0;
+  }
+  return { agentId, sessionId, userId };
+}
+var KNOWN_PROVIDERS = /* @__PURE__ */ new Set(["openai", "anthropic"]);
+function roleOf(msg) {
+  if (!msg || typeof msg !== "object") return void 0;
+  const m = msg;
+  let t;
+  if (typeof m._getType === "function") t = m._getType();
+  else if (typeof m.getType === "function") t = m.getType();
+  else if (typeof m.role === "string") t = m.role;
+  else if (typeof m.type === "string") t = m.type;
+  switch (t) {
+    case "human":
+    case "user":
+      return "user";
+    case "ai":
+    case "assistant":
+      return "assistant";
+    case "tool":
+    case "function":
+      return "tool";
+    default:
+      return void 0;
+  }
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let acc = "";
+  for (const part of content) {
+    if (typeof part === "string") {
+      acc += part;
+    } else if (part && typeof part === "object") {
+      const p = part;
+      if (p.type === "text" && typeof p.text === "string") acc += p.text;
+    }
+  }
+  return acc;
+}
+function toRecentMessages(messages) {
+  if (!Array.isArray(messages)) return [];
+  const out = [];
+  for (const msg of messages) {
+    const role = roleOf(msg);
+    if (role !== "user" && role !== "assistant") continue;
+    const content = contentToText(msg.content).trim();
+    if (!content) continue;
+    out.push({ role, content });
+  }
+  return out;
+}
+function turnStartUserMessage(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return void 0;
+  const last = messages[messages.length - 1];
+  if (roleOf(last) !== "user") return void 0;
+  const text = contentToText(last.content).trim();
+  return text || void 0;
+}
+function extractModel(extraParams, metadata) {
+  const inv = extraParams?.invocation_params ?? {};
+  const fromInv = inv.model ?? inv.model_name ?? inv.modelName;
+  if (typeof fromInv === "string" && fromInv) return fromInv;
+  const fromMeta = metadata?.ls_model_name;
+  return typeof fromMeta === "string" && fromMeta ? fromMeta : void 0;
+}
+function extractProvider(metadata) {
+  const p = metadata?.ls_provider;
+  return typeof p === "string" && KNOWN_PROVIDERS.has(p) ? p : void 0;
+}
+function extractEndMeta(output) {
+  const out = output ?? {};
+  const generations = out.generations;
+  let text = "";
+  const meta = {};
+  if (Array.isArray(generations)) {
+    for (const promptGens of generations) {
+      if (!Array.isArray(promptGens)) continue;
+      for (const gen of promptGens) {
+        if (!gen || typeof gen !== "object") continue;
+        const g = gen;
+        if (typeof g.text === "string" && g.text) text += g.text;
+        const message = g.message;
+        if (message) {
+          if (!text) text += contentToText(message.content);
+          const usage = message.usage_metadata;
+          if (usage) {
+            if (typeof usage.input_tokens === "number") meta.inputTokens = usage.input_tokens;
+            if (typeof usage.output_tokens === "number") meta.outputTokens = usage.output_tokens;
+            const inDetails = usage.input_token_details;
+            if (typeof inDetails?.cache_read === "number") meta.cacheReadTokens = inDetails.cache_read;
+            if (typeof inDetails?.cache_creation === "number")
+              meta.cacheCreationTokens = inDetails.cache_creation;
+          }
+          const respMeta = message.response_metadata;
+          const stop = respMeta?.stop_reason ?? respMeta?.finish_reason;
+          if (typeof stop === "string" && meta.finishReason === void 0) meta.finishReason = stop;
+        }
+        const genInfo = g.generationInfo;
+        const fr = genInfo?.finish_reason ?? genInfo?.finishReason;
+        if (typeof fr === "string" && meta.finishReason === void 0) meta.finishReason = fr;
+      }
+    }
+  }
+  if (meta.inputTokens === void 0 || meta.outputTokens === void 0) {
+    const llmOutput = out.llmOutput ?? {};
+    const usage = llmOutput.tokenUsage ?? llmOutput.usage ?? {};
+    const input = usage.promptTokens ?? usage.input_tokens ?? usage.prompt_tokens;
+    const outp = usage.completionTokens ?? usage.output_tokens ?? usage.completion_tokens;
+    if (meta.inputTokens === void 0 && typeof input === "number") meta.inputTokens = input;
+    if (meta.outputTokens === void 0 && typeof outp === "number") meta.outputTokens = outp;
+  }
+  return { text, meta };
+}
+function safeObserve(fn) {
+  try {
+    fn();
+  } catch (err) {
+    warnRuntimeOnce(err);
+  }
+}
+var warnedRuntime = false;
+function warnRuntimeOnce(err) {
+  if (warnedRuntime) return;
+  warnedRuntime = true;
+  console.warn(
+    `[@firstflow/core/langchain] Telemetry disabled: ${err instanceof Error ? err.message : String(err)}`
+  );
+}
+var FirstflowCallbackHandler = class extends import_base.BaseCallbackHandler {
+  name = "firstflow";
+  runs = /* @__PURE__ */ new Map();
+  // -- starts ----------------------------------------------------------------
+  handleChatModelStart(_llm, messages, runId, _parentRunId, extraParams, _tags, metadata) {
+    const identity = readIdentity(metadata);
+    if (!identity) return;
+    const prompt = Array.isArray(messages) ? messages[0] : messages;
+    this.begin(runId, identity, prompt, extraParams, metadata);
+  }
+  handleLLMStart(_llm, prompts, runId, _parentRunId, extraParams, _tags, metadata) {
+    const identity = readIdentity(metadata);
+    if (!identity) return;
+    const list = Array.isArray(prompts) ? prompts : [];
+    const last = list.length ? list[list.length - 1] : void 0;
+    const pseudo = typeof last === "string" ? [{ role: "user", content: last }] : [];
+    this.begin(runId, identity, pseudo, extraParams, metadata);
+  }
+  begin(runId, identity, prompt, extraParams, metadata) {
+    const recentMessages = toRecentMessages(prompt);
+    const model = extractModel(extraParams, metadata);
+    const provider = extractProvider(metadata);
+    this.runs.set(runId, {
+      identity,
+      startTime: Date.now(),
+      model,
+      provider,
+      recentMessages
+    });
+    const userContent = turnStartUserMessage(prompt);
+    if (!userContent) return;
+    safeObserve(
+      () => getRuntime().observe({
+        agentId: identity.agentId,
+        conversationId: identity.sessionId,
+        userId: identity.userId,
+        role: "user",
+        content: userContent,
+        model,
+        provider,
+        ...recentMessages.length ? { recentMessages } : {}
+      })
+    );
+  }
+  // -- streaming -------------------------------------------------------------
+  handleLLMNewToken(_token, _idx, runId) {
+    const state = this.runs.get(runId);
+    if (state && state.firstTokenTime === void 0) state.firstTokenTime = Date.now();
+  }
+  // -- ends ------------------------------------------------------------------
+  handleLLMEnd(output, runId) {
+    const state = this.runs.get(runId);
+    if (!state) return;
+    this.runs.delete(runId);
+    const { text, meta } = extractEndMeta(output);
+    const { identity, startTime, firstTokenTime, model, provider, recentMessages } = state;
+    safeObserve(
+      () => getRuntime().observe({
+        agentId: identity.agentId,
+        conversationId: identity.sessionId,
+        userId: identity.userId,
+        role: "assistant",
+        content: text,
+        model,
+        provider,
+        ...meta,
+        latencyMs: Date.now() - startTime,
+        ...firstTokenTime !== void 0 ? { timeToFirstTokenMs: firstTokenTime - startTime } : {},
+        httpStatus: 200,
+        ...recentMessages.length ? { recentMessages } : {}
+      })
+    );
+  }
+  handleLLMError(err, runId) {
+    const state = this.runs.get(runId);
+    if (!state) return;
+    this.runs.delete(runId);
+    const { identity, startTime, model, provider } = state;
+    const status = err?.status;
+    safeObserve(
+      () => getRuntime().observe({
+        agentId: identity.agentId,
+        conversationId: identity.sessionId,
+        userId: identity.userId,
+        role: "assistant",
+        content: "",
+        isError: true,
+        error: err instanceof Error ? err.message : String(err),
+        model,
+        provider,
+        latencyMs: Date.now() - startTime,
+        httpStatus: typeof status === "number" ? status : 500
+      })
+    );
+  }
+};
+var _shared;
+function firstflowCallback() {
+  if (!_shared) _shared = new FirstflowCallbackHandler();
+  return _shared;
+}
+function withFirstflow(identity, config) {
+  const handler = firstflowCallback();
+  const existing = Array.isArray(config?.callbacks) ? config.callbacks : config?.callbacks ? [config.callbacks] : [];
+  const callbacks = existing.includes(handler) ? existing : [...existing, handler];
+  return {
+    ...config,
+    callbacks,
+    metadata: {
+      ...config?.metadata ?? {},
+      firstflowAgentId: identity.agentId,
+      sessionId: identity.sessionId,
+      userId: identity.userId
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FirstflowCallbackHandler,
+  firstflowCallback,
+  withFirstflow
+});