@firstflow/core 0.0.5

package/dist/index.js

@@ -0,0 +1,1865 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_FIRSTFLOW_BASE_URL: () => DEFAULT_FIRSTFLOW_BASE_URL,
+  FIRSTFLOW_SERVER_PACKAGE_VERSION: () => FIRSTFLOW_SERVER_PACKAGE_VERSION,
+  feedback: () => feedback,
+  identify: () => identify,
+  listAccessibleAgents: () => listAccessibleAgents,
+  observe: () => observe,
+  outcome: () => outcome,
+  trace: () => trace,
+  track: () => track,
+  wrapClient: () => wrapClient
+});
+module.exports = __toCommonJS(index_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/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 context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.set(key, value);
+      return context2;
+    };
+    self2.deleteValue = (key) => {
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.delete(key);
+      return context2;
+    };
+  }
+};
+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(context2, fn, thisArg, ...args) {
+    return this._getContextManager().with(context2, 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(context2, target) {
+    return this._getContextManager().bind(context2, 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/context-api.js
+var context = ContextAPI.getInstance();
+
+// 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(context2, _carrier) {
+    return context2;
+  }
+  fields() {
+    return [];
+  }
+};
+
+// node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
+var BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+function getBaggage(context2) {
+  return context2.getValue(BAGGAGE_KEY) || void 0;
+}
+function getActiveBaggage() {
+  return getBaggage(ContextAPI.getInstance().active());
+}
+function setBaggage(context2, baggage) {
+  return context2.setValue(BAGGAGE_KEY, baggage);
+}
+function deleteBaggage(context2) {
+  return context2.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(context2, carrier, setter = defaultTextMapSetter) {
+    return this._getGlobalPropagator().inject(context2, 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(context2, carrier, getter = defaultTextMapGetter) {
+    return this._getGlobalPropagator().extract(context2, 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/standalone.ts
+function observe(input) {
+  const { firstflowAgentId, sessionId, userId, ...rest } = input;
+  getRuntime().observe({
+    agentId: firstflowAgentId,
+    conversationId: sessionId,
+    userId,
+    ...rest
+  });
+}
+function outcome(input) {
+  getRuntime().outcome({
+    conversationId: input.sessionId,
+    outcome: input.outcome,
+    intent: input.intent,
+    userId: input.userId
+  });
+}
+function feedback(input) {
+  getRuntime().feedback({
+    conversationId: input.sessionId,
+    rating: input.rating,
+    comment: input.comment,
+    messageId: input.messageId,
+    userId: input.userId
+  });
+}
+function track(args) {
+  getRuntime().track(args.firstflowAgentId, args.userId, args.event, args.properties);
+}
+function identify(args) {
+  getRuntime().identify(args.firstflowAgentId, args.userId, args.traits);
+}
+function trace(args) {
+  const { firstflowAgentId, ...input } = args;
+  getRuntime().trace(firstflowAgentId, input);
+}
+
+// src/wrap.ts
+var INSTRUMENTED_PATHS = /* @__PURE__ */ new Set([
+  "chat.completions.create",
+  "embeddings.create",
+  "responses.create",
+  "messages.create"
+]);
+var warnedIncompleteTagging = false;
+function parseFirstflowMeta(args) {
+  const nextArgs = [...args];
+  for (let i = 0; i < nextArgs.length; i++) {
+    const a = nextArgs[i];
+    if (typeof a !== "object" || a === null) continue;
+    const rec = a;
+    if (!("firstflowAgentId" in rec) && !("sessionId" in rec) && !("userId" in rec)) {
+      continue;
+    }
+    const agentId = typeof rec.firstflowAgentId === "string" ? rec.firstflowAgentId.trim() : "";
+    const sessionId = typeof rec.sessionId === "string" ? rec.sessionId.trim() : "";
+    const userId = typeof rec.userId === "string" ? rec.userId.trim() : "";
+    const { firstflowAgentId: _a, sessionId: _s, userId: _u, ...rest } = rec;
+    nextArgs[i] = rest;
+    if (!agentId || !sessionId || !userId) {
+      if (!warnedIncompleteTagging) {
+        warnedIncompleteTagging = true;
+        console.warn(
+          "[@firstflow/core] LLM call tagged with some but not all of `firstflowAgentId`, `sessionId`, `userId` \u2014 the call was NOT observed. Provide all three to track it."
+        );
+      }
+      return { nextArgs };
+    }
+    return { nextArgs, meta: { agentId, userId, conversationId: sessionId } };
+  }
+  return { nextArgs };
+}
+function extractModel(nextArgs) {
+  const body = nextArgs[0];
+  if (!body || typeof body !== "object") return void 0;
+  const m = body.model;
+  return typeof m === "string" ? m : void 0;
+}
+function detectProvider(path) {
+  return path === "messages.create" ? "anthropic" : "openai";
+}
+function injectOpenAiStreamUsage(nextArgs) {
+  const body = nextArgs[0];
+  if (!body || typeof body !== "object") return nextArgs;
+  const b = body;
+  if (b.stream !== true) return nextArgs;
+  const existing = b.stream_options ?? {};
+  if (existing.include_usage === true) return nextArgs;
+  const patched = [...nextArgs];
+  patched[0] = { ...b, stream_options: { ...existing, include_usage: true } };
+  return patched;
+}
+function extractOpenAiResponseMeta(res) {
+  const usage = res.usage;
+  const details = usage?.prompt_tokens_details;
+  const choice = Array.isArray(res.choices) ? res.choices[0] : void 0;
+  return {
+    inputTokens: typeof usage?.prompt_tokens === "number" ? usage.prompt_tokens : void 0,
+    outputTokens: typeof usage?.completion_tokens === "number" ? usage.completion_tokens : void 0,
+    cacheReadTokens: typeof details?.cached_tokens === "number" ? details.cached_tokens : void 0,
+    finishReason: typeof choice?.finish_reason === "string" ? choice.finish_reason : void 0
+  };
+}
+function extractAnthropicResponseMeta(res) {
+  const usage = res.usage;
+  return {
+    inputTokens: typeof usage?.input_tokens === "number" ? usage.input_tokens : void 0,
+    outputTokens: typeof usage?.output_tokens === "number" ? usage.output_tokens : void 0,
+    cacheReadTokens: typeof usage?.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : void 0,
+    cacheCreationTokens: typeof usage?.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : void 0,
+    finishReason: typeof res.stop_reason === "string" ? res.stop_reason : void 0
+  };
+}
+function accumOpenAiStreamChunkMeta(chunk, acc) {
+  if (!chunk || typeof chunk !== "object") return;
+  const c = chunk;
+  if (c.usage && typeof c.usage === "object") {
+    const usage = c.usage;
+    const details = usage.prompt_tokens_details;
+    if (typeof usage.prompt_tokens === "number") acc.inputTokens = usage.prompt_tokens;
+    if (typeof usage.completion_tokens === "number") acc.outputTokens = usage.completion_tokens;
+    if (typeof details?.cached_tokens === "number") acc.cacheReadTokens = details.cached_tokens;
+  }
+  if (Array.isArray(c.choices) && c.choices[0]) {
+    const choice = c.choices[0];
+    if (typeof choice.finish_reason === "string" && choice.finish_reason) {
+      acc.finishReason = choice.finish_reason;
+    }
+  }
+}
+function accumAnthropicStreamChunkMeta(chunk, acc) {
+  if (!chunk || typeof chunk !== "object") return;
+  const c = chunk;
+  if (c.type === "message_start") {
+    const msg = c.message;
+    const usage = msg?.usage;
+    if (typeof usage?.input_tokens === "number") acc.inputTokens = usage.input_tokens;
+    if (typeof usage?.cache_read_input_tokens === "number")
+      acc.cacheReadTokens = usage.cache_read_input_tokens;
+    if (typeof usage?.cache_creation_input_tokens === "number")
+      acc.cacheCreationTokens = usage.cache_creation_input_tokens;
+  }
+  if (c.type === "message_delta") {
+    const usage = c.usage;
+    const delta = c.delta;
+    if (typeof usage?.output_tokens === "number") acc.outputTokens = usage.output_tokens;
+    if (typeof delta?.stop_reason === "string") acc.finishReason = delta.stop_reason;
+  }
+}
+function isAsyncIterable(v) {
+  return typeof v === "object" && v !== null && Symbol.asyncIterator in v && typeof v[Symbol.asyncIterator] === "function";
+}
+function streamChunkText(chunk) {
+  if (!chunk || typeof chunk !== "object") return "";
+  const c = chunk;
+  if (Array.isArray(c.choices)) {
+    const choice = c.choices[0];
+    if (choice && typeof choice === "object") {
+      const delta = choice.delta;
+      if (delta && typeof delta === "object") {
+        const content = delta.content;
+        if (typeof content === "string") return content;
+      }
+    }
+  }
+  if (c.type === "content_block_delta") {
+    const delta = c.delta;
+    if (delta && typeof delta === "object") {
+      const d = delta;
+      if (d.type === "text_delta" && typeof d.text === "string") return d.text;
+    }
+  }
+  return "";
+}
+function wrapAsyncIterableForAssistantHook(stream, hook, provider, startTime) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      let content = "";
+      let firstChunkTime = -1;
+      let streamError;
+      const acc = {};
+      const accumChunkMeta = provider === "anthropic" ? accumAnthropicStreamChunkMeta : accumOpenAiStreamChunkMeta;
+      try {
+        for await (const chunk of stream) {
+          if (firstChunkTime === -1) firstChunkTime = Date.now();
+          content += streamChunkText(chunk);
+          accumChunkMeta(chunk, acc);
+          yield chunk;
+        }
+      } catch (err) {
+        streamError = err;
+        throw err;
+      } finally {
+        hook(content, {
+          ...acc,
+          httpStatus: streamError != null ? streamError.status ?? 500 : 200,
+          latencyMs: Date.now() - startTime,
+          timeToFirstTokenMs: firstChunkTime === -1 ? void 0 : firstChunkTime - startTime
+        });
+      }
+    }
+  };
+}
+function firstArgBodyStream(nextArgs) {
+  const body = nextArgs[0];
+  return !!(body && typeof body === "object" && body !== null && body.stream === true);
+}
+function extractAnthropicAssistantText(res) {
+  const content = res.content;
+  if (!Array.isArray(content)) return "";
+  let acc = "";
+  for (const item of content) {
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      const o = item;
+      if (o.type === "text" && typeof o.text === "string") {
+        acc += o.text;
+      }
+    }
+  }
+  return acc;
+}
+function extractOpenAiAssistantText(res) {
+  if (!Array.isArray(res.choices) || !res.choices[0] || typeof res.choices[0] !== "object") {
+    return "";
+  }
+  const message = res.choices[0].message;
+  return typeof message?.content === "string" ? message.content : "";
+}
+function isThenable(v) {
+  return !!v && (typeof v === "object" || typeof v === "function") && "then" in v && typeof v.then === "function";
+}
+function messageContentToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let acc = "";
+  for (const part of content) {
+    if (part && typeof part === "object" && !Array.isArray(part)) {
+      const p = part;
+      if (p.type === "text" && typeof p.text === "string") acc += p.text;
+    }
+  }
+  return acc;
+}
+function extractRecentMessages(nextArgs) {
+  const body = nextArgs[0];
+  if (!body || typeof body !== "object") return [];
+  const messages = body.messages;
+  if (!Array.isArray(messages)) return [];
+  const out = [];
+  for (const m of messages) {
+    if (!m || typeof m !== "object") continue;
+    const rec = m;
+    if (rec.role !== "user" && rec.role !== "assistant") continue;
+    const content = messageContentToText(rec.content).trim();
+    if (!content) continue;
+    out.push({ role: rec.role, content });
+  }
+  return out;
+}
+function extractTurnStartUserMessage(nextArgs) {
+  const body = nextArgs[0];
+  if (!body || typeof body !== "object") return void 0;
+  const messages = body.messages;
+  if (!Array.isArray(messages) || messages.length === 0) return void 0;
+  const last = messages[messages.length - 1];
+  if (!last || typeof last !== "object") return void 0;
+  const rec = last;
+  if (rec.role !== "user") return void 0;
+  const text = messageContentToText(rec.content).trim();
+  return text || void 0;
+}
+function withFirstflowBaggage(meta, fn) {
+  const base = propagation.getBaggage(context.active()) ?? propagation.createBaggage();
+  const bag = base.setEntry("firstflow.user_id", { value: meta.userId }).setEntry("firstflow.agent_id", { value: meta.agentId });
+  return context.with(propagation.setBaggage(context.active(), bag), fn);
+}
+function maybeObserveUserMessage(path, nextArgs, meta, ctx) {
+  if (!ctx.onUserMessage) return;
+  if (path !== "chat.completions.create" && path !== "messages.create") return;
+  if (!meta.conversationId) return;
+  const content = extractTurnStartUserMessage(nextArgs);
+  if (!content) return;
+  const recentMessages = extractRecentMessages(nextArgs);
+  ctx.onUserMessage({
+    agentId: meta.agentId,
+    conversationId: meta.conversationId,
+    userId: meta.userId,
+    role: "user",
+    content,
+    model: extractModel(nextArgs),
+    provider: detectProvider(path),
+    ...recentMessages.length ? { recentMessages } : {}
+  });
+}
+function maybeAttachAssistantHook(path, nextArgs, result, meta, ctx, startTime) {
+  if (!ctx.onAssistantComplete) return void 0;
+  if (path !== "chat.completions.create" && path !== "messages.create") {
+    return void 0;
+  }
+  const convId = meta.conversationId;
+  const recentMessages = extractRecentMessages(nextArgs);
+  const model = extractModel(nextArgs);
+  const provider = detectProvider(path);
+  const extractFull = path === "chat.completions.create" ? extractOpenAiAssistantText : extractAnthropicAssistantText;
+  const extractMeta = path === "chat.completions.create" ? extractOpenAiResponseMeta : extractAnthropicResponseMeta;
+  const emit = (content, llmMeta) => {
+    if (!convId) return;
+    ctx.onAssistantComplete?.({
+      agentId: meta.agentId,
+      conversationId: convId,
+      userId: meta.userId,
+      role: "assistant",
+      content,
+      model,
+      provider,
+      ...llmMeta,
+      ...recentMessages.length ? { recentMessages } : {}
+    });
+  };
+  if (firstArgBodyStream(nextArgs)) {
+    const wrapStream = (stream) => wrapAsyncIterableForAssistantHook(
+      stream,
+      (content, streamMeta) => emit(content, streamMeta),
+      provider,
+      startTime
+    );
+    if (isAsyncIterable(result)) {
+      return wrapStream(result);
+    }
+    if (isThenable(result)) {
+      return result.then(
+        (resolved) => isAsyncIterable(resolved) ? wrapStream(resolved) : resolved
+      );
+    }
+    return void 0;
+  }
+  if (isThenable(result)) {
+    return result.then((res) => {
+      const latencyMs = Date.now() - startTime;
+      const resMeta = extractMeta(res ?? {});
+      emit(extractFull(res ?? {}), { ...resMeta, latencyMs, httpStatus: 200 });
+      return res;
+    });
+  }
+  return void 0;
+}
+function wrapInstrumentedInvocation(path, original, thisArg, args, ctx) {
+  const parsed = parseFirstflowMeta(args);
+  const { meta } = parsed;
+  let nextArgs = parsed.nextArgs;
+  if (path === "chat.completions.create") {
+    nextArgs = injectOpenAiStreamUsage(nextArgs);
+  }
+  const startTime = Date.now();
+  const run = () => {
+    if (meta) maybeObserveUserMessage(path, nextArgs, meta, ctx);
+    let result;
+    try {
+      result = Reflect.apply(original, thisArg, nextArgs);
+    } catch (err) {
+      if (meta?.conversationId && ctx.onError) {
+        ctx.onError({
+          agentId: meta.agentId,
+          conversationId: meta.conversationId,
+          userId: meta.userId,
+          isError: true,
+          error: err instanceof Error ? err.message : String(err),
+          model: extractModel(nextArgs),
+          provider: detectProvider(path),
+          latencyMs: Date.now() - startTime,
+          httpStatus: err.status
+        });
+      }
+      throw err;
+    }
+    if (isThenable(result) && meta?.conversationId && ctx.onError) {
+      result = result.catch((err) => {
+        ctx.onError({
+          agentId: meta.agentId,
+          conversationId: meta.conversationId,
+          userId: meta.userId,
+          isError: true,
+          error: err instanceof Error ? err.message : String(err),
+          model: extractModel(nextArgs),
+          provider: detectProvider(path),
+          latencyMs: Date.now() - startTime,
+          httpStatus: err.status
+        });
+        return Promise.reject(err);
+      });
+    }
+    if (meta) {
+      const hooked = maybeAttachAssistantHook(path, nextArgs, result, meta, ctx, startTime);
+      if (hooked !== void 0) return hooked;
+    }
+    return result;
+  };
+  if (meta) {
+    return withFirstflowBaggage(meta, run);
+  }
+  return run();
+}
+function createNestedProxy(target, path, ctx) {
+  return new Proxy(target, {
+    get(_t, prop, receiver) {
+      const key = String(prop);
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        const joined = [...path, key].join(".");
+        return (...fnArgs) => {
+          if (INSTRUMENTED_PATHS.has(joined)) {
+            return wrapInstrumentedInvocation(
+              joined,
+              value,
+              target,
+              fnArgs,
+              ctx
+            );
+          }
+          return Reflect.apply(value, target, fnArgs);
+        };
+      }
+      if (value !== null && typeof value === "object") {
+        return createNestedProxy(value, [...path, key], ctx);
+      }
+      return value;
+    }
+  });
+}
+function wrapClient(client, ctx) {
+  return createNestedProxy(client, [], ctx);
+}
+
+// src/agents.ts
+async function listAccessibleAgents(opts) {
+  const base = (opts.baseUrl ?? DEFAULT_FIRSTFLOW_BASE_URL).replace(/\/$/, "");
+  const apiKey = opts.apiKey.trim();
+  if (!apiKey) return { agents: [], workspaceId: "", publishableKey: null };
+  const res = await fetch(`${base}/v1/agents/accessible`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${apiKey}` },
+    cache: "no-store"
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    throw new Error(
+      `[Firstflow] listAccessibleAgents: HTTP ${res.status} \u2014 ${detail.slice(0, 200)}`
+    );
+  }
+  const json = await res.json();
+  return {
+    agents: (json.data ?? []).map((a) => ({ id: a.id, name: a.name ?? null })),
+    workspaceId: json.workspaceId ?? "",
+    publishableKey: json.publishableKey ?? null
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FIRSTFLOW_BASE_URL,
+  FIRSTFLOW_SERVER_PACKAGE_VERSION,
+  feedback,
+  identify,
+  listAccessibleAgents,
+  observe,
+  outcome,
+  trace,
+  track,
+  wrapClient
+});