@elizaos/plugin-trajectory-logger 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/node/index.node.js

@@ -1,5 +1,2485 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../../../node_modules/drizzle-orm/entity.js
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+var entityKind, hasOwnEntityKind;
+var init_entity = __esm(() => {
+  entityKind = Symbol.for("drizzle:entityKind");
+  hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+});
+
+// ../../../../node_modules/drizzle-orm/column.js
+var Column;
+var init_column = __esm(() => {
+  init_entity();
+  Column = class Column {
+    constructor(table, config) {
+      this.table = table;
+      this.config = config;
+      this.name = config.name;
+      this.keyAsName = config.keyAsName;
+      this.notNull = config.notNull;
+      this.default = config.default;
+      this.defaultFn = config.defaultFn;
+      this.onUpdateFn = config.onUpdateFn;
+      this.hasDefault = config.hasDefault;
+      this.primary = config.primaryKey;
+      this.isUnique = config.isUnique;
+      this.uniqueName = config.uniqueName;
+      this.uniqueType = config.uniqueType;
+      this.dataType = config.dataType;
+      this.columnType = config.columnType;
+      this.generated = config.generated;
+      this.generatedIdentity = config.generatedIdentity;
+    }
+    static [entityKind] = "Column";
+    name;
+    keyAsName;
+    primary;
+    notNull;
+    default;
+    defaultFn;
+    onUpdateFn;
+    hasDefault;
+    isUnique;
+    uniqueName;
+    uniqueType;
+    dataType;
+    columnType;
+    enumValues = undefined;
+    generated = undefined;
+    generatedIdentity = undefined;
+    config;
+    mapFromDriverValue(value) {
+      return value;
+    }
+    mapToDriverValue(value) {
+      return value;
+    }
+    shouldDisableInsert() {
+      return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder;
+var init_column_builder = __esm(() => {
+  init_entity();
+  ColumnBuilder = class ColumnBuilder {
+    static [entityKind] = "ColumnBuilder";
+    config;
+    constructor(name, dataType, columnType) {
+      this.config = {
+        name,
+        keyAsName: name === "",
+        notNull: false,
+        default: undefined,
+        hasDefault: false,
+        primaryKey: false,
+        isUnique: false,
+        uniqueName: undefined,
+        uniqueType: undefined,
+        dataType,
+        columnType,
+        generated: undefined
+      };
+    }
+    $type() {
+      return this;
+    }
+    notNull() {
+      this.config.notNull = true;
+      return this;
+    }
+    default(value) {
+      this.config.default = value;
+      this.config.hasDefault = true;
+      return this;
+    }
+    $defaultFn(fn) {
+      this.config.defaultFn = fn;
+      this.config.hasDefault = true;
+      return this;
+    }
+    $default = this.$defaultFn;
+    $onUpdateFn(fn) {
+      this.config.onUpdateFn = fn;
+      this.config.hasDefault = true;
+      return this;
+    }
+    $onUpdate = this.$onUpdateFn;
+    primaryKey() {
+      this.config.primaryKey = true;
+      this.config.notNull = true;
+      return this;
+    }
+    setName(name) {
+      if (this.config.name !== "")
+        return;
+      this.config.name = name;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/table.utils.js
+var TableName;
+var init_table_utils = __esm(() => {
+  TableName = Symbol.for("drizzle:Name");
+});
+
+// ../../../../node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+var init_tracing_utils = () => {};
+
+// ../../../../node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var init_unique_constraint = __esm(() => {
+  init_table_utils();
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumn, ExtraConfigColumn;
+var init_common = __esm(() => {
+  init_column();
+  init_entity();
+  init_unique_constraint();
+  PgColumn = class PgColumn extends Column {
+    constructor(table, config) {
+      if (!config.uniqueName) {
+        config.uniqueName = uniqueKeyName(table, [config.name]);
+      }
+      super(table, config);
+      this.table = table;
+    }
+    static [entityKind] = "PgColumn";
+  };
+  ExtraConfigColumn = class ExtraConfigColumn extends PgColumn {
+    static [entityKind] = "ExtraConfigColumn";
+    getSQLType() {
+      return this.getSQLType();
+    }
+    indexConfig = {
+      order: this.config.order ?? "asc",
+      nulls: this.config.nulls ?? "last",
+      opClass: this.config.opClass
+    };
+    defaultConfig = {
+      order: "asc",
+      nulls: "last",
+      opClass: undefined
+    };
+    asc() {
+      this.indexConfig.order = "asc";
+      return this;
+    }
+    desc() {
+      this.indexConfig.order = "desc";
+      return this;
+    }
+    nullsFirst() {
+      this.indexConfig.nulls = "first";
+      return this;
+    }
+    nullsLast() {
+      this.indexConfig.nulls = "last";
+      return this;
+    }
+    op(opClass) {
+      this.indexConfig.opClass = opClass;
+      return this;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/columns/enum.js
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+var PgEnumObjectColumn, isPgEnumSym, PgEnumColumn;
+var init_enum = __esm(() => {
+  init_entity();
+  init_common();
+  PgEnumObjectColumn = class PgEnumObjectColumn extends PgColumn {
+    static [entityKind] = "PgEnumObjectColumn";
+    enum;
+    enumValues = this.config.enum.enumValues;
+    constructor(table, config) {
+      super(table, config);
+      this.enum = config.enum;
+    }
+    getSQLType() {
+      return this.enum.enumName;
+    }
+  };
+  isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+  PgEnumColumn = class PgEnumColumn extends PgColumn {
+    static [entityKind] = "PgEnumColumn";
+    enum = this.config.enum;
+    enumValues = this.config.enum.enumValues;
+    constructor(table, config) {
+      super(table, config);
+      this.enum = config.enum;
+    }
+    getSQLType() {
+      return this.enum.enumName;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/subquery.js
+var Subquery, WithSubquery;
+var init_subquery = __esm(() => {
+  init_entity();
+  Subquery = class Subquery {
+    static [entityKind] = "Subquery";
+    constructor(sql, fields, alias, isWith = false, usedTables = []) {
+      this._ = {
+        brand: "Subquery",
+        sql,
+        selectedFields: fields,
+        alias,
+        isWith,
+        usedTables
+      };
+    }
+  };
+  WithSubquery = class WithSubquery extends Subquery {
+    static [entityKind] = "WithSubquery";
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/version.js
+var version = "0.45.1";
+var init_version = () => {};
+
+// ../../../../node_modules/drizzle-orm/tracing.js
+var otel, rawTracer, tracer;
+var init_tracing = __esm(() => {
+  init_tracing_utils();
+  init_version();
+  tracer = {
+    startActiveSpan(name, fn) {
+      if (!otel) {
+        return fn();
+      }
+      if (!rawTracer) {
+        rawTracer = otel.trace.getTracer("drizzle-orm", version);
+      }
+      return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
+        try {
+          return fn(span);
+        } catch (e) {
+          span.setStatus({
+            code: otel2.SpanStatusCode.ERROR,
+            message: e instanceof Error ? e.message : "Unknown error"
+          });
+          throw e;
+        } finally {
+          span.end();
+        }
+      }), otel, rawTracer);
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig;
+var init_view_common = __esm(() => {
+  ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+});
+
+// ../../../../node_modules/drizzle-orm/table.js
+function isTable(table) {
+  return typeof table === "object" && table !== null && IsDrizzleTable in table;
+}
+function getTableName(table) {
+  return table[TableName];
+}
+function getTableUniqueName(table) {
+  return `${table[Schema] ?? "public"}.${table[TableName]}`;
+}
+var Schema, Columns, ExtraConfigColumns, OriginalName, BaseName, IsAlias, ExtraConfigBuilder, IsDrizzleTable, Table;
+var init_table = __esm(() => {
+  init_entity();
+  init_table_utils();
+  Schema = Symbol.for("drizzle:Schema");
+  Columns = Symbol.for("drizzle:Columns");
+  ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+  OriginalName = Symbol.for("drizzle:OriginalName");
+  BaseName = Symbol.for("drizzle:BaseName");
+  IsAlias = Symbol.for("drizzle:IsAlias");
+  ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+  IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+  Table = class Table {
+    static [entityKind] = "Table";
+    static Symbol = {
+      Name: TableName,
+      Schema,
+      OriginalName,
+      Columns,
+      ExtraConfigColumns,
+      BaseName,
+      IsAlias,
+      ExtraConfigBuilder
+    };
+    [TableName];
+    [OriginalName];
+    [Schema];
+    [Columns];
+    [ExtraConfigColumns];
+    [BaseName];
+    [IsAlias] = false;
+    [IsDrizzleTable] = true;
+    [ExtraConfigBuilder] = undefined;
+    constructor(name, schema, baseName) {
+      this[TableName] = this[OriginalName] = name;
+      this[Schema] = schema;
+      this[BaseName] = baseName;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+  return value !== null && value !== undefined && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+function name(value) {
+  return new Name(value);
+}
+function isDriverValueEncoder(value) {
+  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
+}
+function param(value, encoder) {
+  return new Param(value, encoder);
+}
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+function placeholder(name2) {
+  return new Placeholder(name2);
+}
+function fillPlaceholders(params, values) {
+  return params.map((p) => {
+    if (is(p, Placeholder)) {
+      if (!(p.name in values)) {
+        throw new Error(`No value for placeholder "${p.name}" was provided`);
+      }
+      return values[p.name];
+    }
+    if (is(p, Param) && is(p.value, Placeholder)) {
+      if (!(p.value.name in values)) {
+        throw new Error(`No value for placeholder "${p.value.name}" was provided`);
+      }
+      return p.encoder.mapToDriverValue(values[p.value.name]);
+    }
+    return p;
+  });
+}
+function isView(view) {
+  return typeof view === "object" && view !== null && IsDrizzleView in view;
+}
+function getViewName(view) {
+  return view[ViewBaseConfig].name;
+}
+var FakePrimitiveParam, StringChunk, SQL, Name, noopDecoder, noopEncoder, noopMapper, Param, Placeholder, IsDrizzleView, View;
+var init_sql = __esm(() => {
+  init_entity();
+  init_enum();
+  init_subquery();
+  init_tracing();
+  init_view_common();
+  init_column();
+  init_table();
+  FakePrimitiveParam = class FakePrimitiveParam {
+    static [entityKind] = "FakePrimitiveParam";
+  };
+  StringChunk = class StringChunk {
+    static [entityKind] = "StringChunk";
+    value;
+    constructor(value) {
+      this.value = Array.isArray(value) ? value : [value];
+    }
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  SQL = class SQL {
+    constructor(queryChunks) {
+      this.queryChunks = queryChunks;
+      for (const chunk of queryChunks) {
+        if (is(chunk, Table)) {
+          const schemaName = chunk[Table.Symbol.Schema];
+          this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+        }
+      }
+    }
+    static [entityKind] = "SQL";
+    decoder = noopDecoder;
+    shouldInlineParams = false;
+    usedTables = [];
+    append(query) {
+      this.queryChunks.push(...query.queryChunks);
+      return this;
+    }
+    toQuery(config) {
+      return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+        const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+        span?.setAttributes({
+          "drizzle.query.text": query.sql,
+          "drizzle.query.params": JSON.stringify(query.params)
+        });
+        return query;
+      });
+    }
+    buildQueryFromSourceParams(chunks, _config) {
+      const config = Object.assign({}, _config, {
+        inlineParams: _config.inlineParams || this.shouldInlineParams,
+        paramStartIndex: _config.paramStartIndex || { value: 0 }
+      });
+      const {
+        casing,
+        escapeName,
+        escapeParam,
+        prepareTyping,
+        inlineParams,
+        paramStartIndex
+      } = config;
+      return mergeQueries(chunks.map((chunk) => {
+        if (is(chunk, StringChunk)) {
+          return { sql: chunk.value.join(""), params: [] };
+        }
+        if (is(chunk, Name)) {
+          return { sql: escapeName(chunk.value), params: [] };
+        }
+        if (chunk === undefined) {
+          return { sql: "", params: [] };
+        }
+        if (Array.isArray(chunk)) {
+          const result = [new StringChunk("(")];
+          for (const [i, p] of chunk.entries()) {
+            result.push(p);
+            if (i < chunk.length - 1) {
+              result.push(new StringChunk(", "));
+            }
+          }
+          result.push(new StringChunk(")"));
+          return this.buildQueryFromSourceParams(result, config);
+        }
+        if (is(chunk, SQL)) {
+          return this.buildQueryFromSourceParams(chunk.queryChunks, {
+            ...config,
+            inlineParams: inlineParams || chunk.shouldInlineParams
+          });
+        }
+        if (is(chunk, Table)) {
+          const schemaName = chunk[Table.Symbol.Schema];
+          const tableName = chunk[Table.Symbol.Name];
+          return {
+            sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+            params: []
+          };
+        }
+        if (is(chunk, Column)) {
+          const columnName = casing.getColumnCasing(chunk);
+          if (_config.invokeSource === "indexes") {
+            return { sql: escapeName(columnName), params: [] };
+          }
+          const schemaName = chunk.table[Table.Symbol.Schema];
+          return {
+            sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+            params: []
+          };
+        }
+        if (is(chunk, View)) {
+          const schemaName = chunk[ViewBaseConfig].schema;
+          const viewName = chunk[ViewBaseConfig].name;
+          return {
+            sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+            params: []
+          };
+        }
+        if (is(chunk, Param)) {
+          if (is(chunk.value, Placeholder)) {
+            return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+          }
+          const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+          if (is(mappedValue, SQL)) {
+            return this.buildQueryFromSourceParams([mappedValue], config);
+          }
+          if (inlineParams) {
+            return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+          }
+          let typings = ["none"];
+          if (prepareTyping) {
+            typings = [prepareTyping(chunk.encoder)];
+          }
+          return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+        }
+        if (is(chunk, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+          return { sql: escapeName(chunk.fieldAlias), params: [] };
+        }
+        if (is(chunk, Subquery)) {
+          if (chunk._.isWith) {
+            return { sql: escapeName(chunk._.alias), params: [] };
+          }
+          return this.buildQueryFromSourceParams([
+            new StringChunk("("),
+            chunk._.sql,
+            new StringChunk(") "),
+            new Name(chunk._.alias)
+          ], config);
+        }
+        if (isPgEnum(chunk)) {
+          if (chunk.schema) {
+            return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+          }
+          return { sql: escapeName(chunk.enumName), params: [] };
+        }
+        if (isSQLWrapper(chunk)) {
+          if (chunk.shouldOmitSQLParens?.()) {
+            return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+          }
+          return this.buildQueryFromSourceParams([
+            new StringChunk("("),
+            chunk.getSQL(),
+            new StringChunk(")")
+          ], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(chunk, config), params: [] };
+        }
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }));
+    }
+    mapInlineParam(chunk, { escapeString }) {
+      if (chunk === null) {
+        return "null";
+      }
+      if (typeof chunk === "number" || typeof chunk === "boolean") {
+        return chunk.toString();
+      }
+      if (typeof chunk === "string") {
+        return escapeString(chunk);
+      }
+      if (typeof chunk === "object") {
+        const mappedValueAsString = chunk.toString();
+        if (mappedValueAsString === "[object Object]") {
+          return escapeString(JSON.stringify(chunk));
+        }
+        return escapeString(mappedValueAsString);
+      }
+      throw new Error("Unexpected param value: " + chunk);
+    }
+    getSQL() {
+      return this;
+    }
+    as(alias) {
+      if (alias === undefined) {
+        return this;
+      }
+      return new SQL.Aliased(this, alias);
+    }
+    mapWith(decoder) {
+      this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+      return this;
+    }
+    inlineParams() {
+      this.shouldInlineParams = true;
+      return this;
+    }
+    if(condition) {
+      return condition ? this : undefined;
+    }
+  };
+  Name = class Name {
+    constructor(value) {
+      this.value = value;
+    }
+    static [entityKind] = "Name";
+    brand;
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  noopDecoder = {
+    mapFromDriverValue: (value) => value
+  };
+  noopEncoder = {
+    mapToDriverValue: (value) => value
+  };
+  noopMapper = {
+    ...noopDecoder,
+    ...noopEncoder
+  };
+  Param = class Param {
+    constructor(value, encoder = noopEncoder) {
+      this.value = value;
+      this.encoder = encoder;
+    }
+    static [entityKind] = "Param";
+    brand;
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  ((sql2) => {
+    function empty() {
+      return new SQL([]);
+    }
+    sql2.empty = empty;
+    function fromList(list) {
+      return new SQL(list);
+    }
+    sql2.fromList = fromList;
+    function raw(str) {
+      return new SQL([new StringChunk(str)]);
+    }
+    sql2.raw = raw;
+    function join(chunks, separator) {
+      const result = [];
+      for (const [i, chunk] of chunks.entries()) {
+        if (i > 0 && separator !== undefined) {
+          result.push(separator);
+        }
+        result.push(chunk);
+      }
+      return new SQL(result);
+    }
+    sql2.join = join;
+    function identifier(value) {
+      return new Name(value);
+    }
+    sql2.identifier = identifier;
+    function placeholder2(name2) {
+      return new Placeholder(name2);
+    }
+    sql2.placeholder = placeholder2;
+    function param2(value, encoder) {
+      return new Param(value, encoder);
+    }
+    sql2.param = param2;
+  })(sql || (sql = {}));
+  ((SQL2) => {
+
+    class Aliased {
+      constructor(sql2, fieldAlias) {
+        this.sql = sql2;
+        this.fieldAlias = fieldAlias;
+      }
+      static [entityKind] = "SQL.Aliased";
+      isSelectionField = false;
+      getSQL() {
+        return this.sql;
+      }
+      clone() {
+        return new Aliased(this.sql, this.fieldAlias);
+      }
+    }
+    SQL2.Aliased = Aliased;
+  })(SQL || (SQL = {}));
+  Placeholder = class Placeholder {
+    constructor(name2) {
+      this.name = name2;
+    }
+    static [entityKind] = "Placeholder";
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+  View = class View {
+    static [entityKind] = "View";
+    [ViewBaseConfig];
+    [IsDrizzleView] = true;
+    constructor({ name: name2, schema, selectedFields, query }) {
+      this[ViewBaseConfig] = {
+        name: name2,
+        originalName: name2,
+        schema,
+        selectedFields,
+        query,
+        isExisting: !query,
+        isAlias: false
+      };
+    }
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  Column.prototype.getSQL = function() {
+    return new SQL([this]);
+  };
+  Table.prototype.getSQL = function() {
+    return new SQL([this]);
+  };
+  Subquery.prototype.getSQL = function() {
+    return new SQL([this]);
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/alias.js
+function aliasedTable(table, tableAlias) {
+  return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));
+}
+function aliasedRelation(relation, tableAlias) {
+  return new Proxy(relation, new RelationTableAliasProxyHandler(tableAlias));
+}
+function aliasedTableColumn(column, tableAlias) {
+  return new Proxy(column, new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false))));
+}
+function mapColumnsInAliasedSQLToAlias(query, alias) {
+  return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias), query.fieldAlias);
+}
+function mapColumnsInSQLToAlias(query, alias) {
+  return sql.join(query.queryChunks.map((c) => {
+    if (is(c, Column)) {
+      return aliasedTableColumn(c, alias);
+    }
+    if (is(c, SQL)) {
+      return mapColumnsInSQLToAlias(c, alias);
+    }
+    if (is(c, SQL.Aliased)) {
+      return mapColumnsInAliasedSQLToAlias(c, alias);
+    }
+    return c;
+  }));
+}
+var ColumnAliasProxyHandler, TableAliasProxyHandler, RelationTableAliasProxyHandler;
+var init_alias = __esm(() => {
+  init_column();
+  init_entity();
+  init_sql();
+  init_table();
+  init_view_common();
+  ColumnAliasProxyHandler = class ColumnAliasProxyHandler {
+    constructor(table) {
+      this.table = table;
+    }
+    static [entityKind] = "ColumnAliasProxyHandler";
+    get(columnObj, prop) {
+      if (prop === "table") {
+        return this.table;
+      }
+      return columnObj[prop];
+    }
+  };
+  TableAliasProxyHandler = class TableAliasProxyHandler {
+    constructor(alias, replaceOriginalName) {
+      this.alias = alias;
+      this.replaceOriginalName = replaceOriginalName;
+    }
+    static [entityKind] = "TableAliasProxyHandler";
+    get(target, prop) {
+      if (prop === Table.Symbol.IsAlias) {
+        return true;
+      }
+      if (prop === Table.Symbol.Name) {
+        return this.alias;
+      }
+      if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) {
+        return this.alias;
+      }
+      if (prop === ViewBaseConfig) {
+        return {
+          ...target[ViewBaseConfig],
+          name: this.alias,
+          isAlias: true
+        };
+      }
+      if (prop === Table.Symbol.Columns) {
+        const columns = target[Table.Symbol.Columns];
+        if (!columns) {
+          return columns;
+        }
+        const proxiedColumns = {};
+        Object.keys(columns).map((key) => {
+          proxiedColumns[key] = new Proxy(columns[key], new ColumnAliasProxyHandler(new Proxy(target, this)));
+        });
+        return proxiedColumns;
+      }
+      const value = target[prop];
+      if (is(value, Column)) {
+        return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));
+      }
+      return value;
+    }
+  };
+  RelationTableAliasProxyHandler = class RelationTableAliasProxyHandler {
+    constructor(alias) {
+      this.alias = alias;
+    }
+    static [entityKind] = "RelationTableAliasProxyHandler";
+    get(target, prop) {
+      if (prop === "sourceTable") {
+        return aliasedTable(target.sourceTable, this.alias);
+      }
+      return target[prop];
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/errors.js
+var DrizzleError, DrizzleQueryError, TransactionRollbackError;
+var init_errors = __esm(() => {
+  init_entity();
+  DrizzleError = class DrizzleError extends Error {
+    static [entityKind] = "DrizzleError";
+    constructor({ message, cause }) {
+      super(message);
+      this.name = "DrizzleError";
+      this.cause = cause;
+    }
+  };
+  DrizzleQueryError = class DrizzleQueryError extends Error {
+    constructor(query, params, cause) {
+      super(`Failed query: ${query}
+params: ${params}`);
+      this.query = query;
+      this.params = params;
+      this.cause = cause;
+      Error.captureStackTrace(this, DrizzleQueryError);
+      if (cause)
+        this.cause = cause;
+    }
+  };
+  TransactionRollbackError = class TransactionRollbackError extends DrizzleError {
+    static [entityKind] = "TransactionRollbackError";
+    constructor() {
+      super({ message: "Rollback" });
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/logger.js
+var ConsoleLogWriter, DefaultLogger, NoopLogger;
+var init_logger = __esm(() => {
+  init_entity();
+  ConsoleLogWriter = class ConsoleLogWriter {
+    static [entityKind] = "ConsoleLogWriter";
+    write(message) {
+      console.log(message);
+    }
+  };
+  DefaultLogger = class DefaultLogger {
+    static [entityKind] = "DefaultLogger";
+    writer;
+    constructor(config) {
+      this.writer = config?.writer ?? new ConsoleLogWriter;
+    }
+    logQuery(query, params) {
+      const stringifiedParams = params.map((p) => {
+        try {
+          return JSON.stringify(p);
+        } catch {
+          return String(p);
+        }
+      });
+      const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(", ")}]` : "";
+      this.writer.write(`Query: ${query}${paramsStr}`);
+    }
+  };
+  NoopLogger = class NoopLogger {
+    static [entityKind] = "NoopLogger";
+    logQuery() {}
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/query-promise.js
+var QueryPromise;
+var init_query_promise = __esm(() => {
+  init_entity();
+  QueryPromise = class QueryPromise {
+    static [entityKind] = "QueryPromise";
+    [Symbol.toStringTag] = "QueryPromise";
+    catch(onRejected) {
+      return this.then(undefined, onRejected);
+    }
+    finally(onFinally) {
+      return this.then((value) => {
+        onFinally?.();
+        return value;
+      }, (reason) => {
+        onFinally?.();
+        throw reason;
+      });
+    }
+    then(onFulfilled, onRejected) {
+      return this.execute().then(onFulfilled, onRejected);
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/utils.js
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = columns.reduce((result2, { path, field }, columnIndex) => {
+    let decoder;
+    if (is(field, Column)) {
+      decoder = field;
+    } else if (is(field, SQL)) {
+      decoder = field.decoder;
+    } else if (is(field, Subquery)) {
+      decoder = field._.sql.decoder;
+    } else {
+      decoder = field.sql.decoder;
+    }
+    let node = result2;
+    for (const [pathChunkIndex, pathChunk] of path.entries()) {
+      if (pathChunkIndex < path.length - 1) {
+        if (!(pathChunk in node)) {
+          node[pathChunk] = {};
+        }
+        node = node[pathChunk];
+      } else {
+        const rawValue = row[columnIndex];
+        const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+        if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
+          const objectName = path[0];
+          if (!(objectName in nullifyMap)) {
+            nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+          } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
+            nullifyMap[objectName] = false;
+          }
+        }
+      }
+    }
+    return result2;
+  }, {});
+  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
+        result[objectName] = null;
+      }
+    }
+  }
+  return result;
+}
+function orderSelectedFields(fields, pathPrefix) {
+  return Object.entries(fields).reduce((result, [name2, field]) => {
+    if (typeof name2 !== "string") {
+      return result;
+    }
+    const newPath = pathPrefix ? [...pathPrefix, name2] : [name2];
+    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) {
+      result.push({ path: newPath, field });
+    } else if (is(field, Table)) {
+      result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
+    } else {
+      result.push(...orderSelectedFields(field, newPath));
+    }
+    return result;
+  }, []);
+}
+function haveSameKeys(left, right) {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (const [index, key] of leftKeys.entries()) {
+    if (key !== rightKeys[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mapUpdateSet(table, values) {
+  const entries = Object.entries(values).filter(([, value]) => value !== undefined).map(([key, value]) => {
+    if (is(value, SQL) || is(value, Column)) {
+      return [key, value];
+    } else {
+      return [key, new Param(value, table[Table.Symbol.Columns][key])];
+    }
+  });
+  if (entries.length === 0) {
+    throw new Error("No values to set");
+  }
+  return Object.fromEntries(entries);
+}
+function applyMixins(baseClass, extendedClasses) {
+  for (const extendedClass of extendedClasses) {
+    for (const name2 of Object.getOwnPropertyNames(extendedClass.prototype)) {
+      if (name2 === "constructor")
+        continue;
+      Object.defineProperty(baseClass.prototype, name2, Object.getOwnPropertyDescriptor(extendedClass.prototype, name2) || /* @__PURE__ */ Object.create(null));
+    }
+  }
+}
+function getTableColumns(table) {
+  return table[Table.Symbol.Columns];
+}
+function getViewSelectedFields(view) {
+  return view[ViewBaseConfig].selectedFields;
+}
+function getTableLikeName(table) {
+  return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? undefined : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];
+}
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+function isConfig(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  if (data.constructor.name !== "Object")
+    return false;
+  if ("logger" in data) {
+    const type = typeof data["logger"];
+    if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("schema" in data) {
+    const type = typeof data["schema"];
+    if (type !== "object" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("casing" in data) {
+    const type = typeof data["casing"];
+    if (type !== "string" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("mode" in data) {
+    if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== undefined)
+      return false;
+    return true;
+  }
+  if ("connection" in data) {
+    const type = typeof data["connection"];
+    if (type !== "string" && type !== "object" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("client" in data) {
+    const type = typeof data["client"];
+    if (type !== "object" && type !== "function" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if (Object.keys(data).length === 0)
+    return true;
+  return false;
+}
+var textDecoder;
+var init_utils = __esm(() => {
+  init_column();
+  init_entity();
+  init_sql();
+  init_subquery();
+  init_table();
+  init_view_common();
+  textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/table.js
+var InlineForeignKeys, EnableRLS, PgTable;
+var init_table2 = __esm(() => {
+  init_entity();
+  init_table();
+  InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
+  EnableRLS = Symbol.for("drizzle:EnableRLS");
+  PgTable = class PgTable extends Table {
+    static [entityKind] = "PgTable";
+    static Symbol = Object.assign({}, Table.Symbol, {
+      InlineForeignKeys,
+      EnableRLS
+    });
+    [InlineForeignKeys] = [];
+    [EnableRLS] = false;
+    [Table.Symbol.ExtraConfigBuilder] = undefined;
+    [Table.Symbol.ExtraConfigColumns] = {};
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/primary-keys.js
+var PrimaryKeyBuilder, PrimaryKey;
+var init_primary_keys = __esm(() => {
+  init_entity();
+  init_table2();
+  PrimaryKeyBuilder = class PrimaryKeyBuilder {
+    static [entityKind] = "PgPrimaryKeyBuilder";
+    columns;
+    name;
+    constructor(columns, name2) {
+      this.columns = columns;
+      this.name = name2;
+    }
+    build(table) {
+      return new PrimaryKey(table, this.columns, this.name);
+    }
+  };
+  PrimaryKey = class PrimaryKey {
+    constructor(table, columns, name2) {
+      this.table = table;
+      this.columns = columns;
+      this.name = name2;
+    }
+    static [entityKind] = "PgPrimaryKey";
+    columns;
+    name;
+    getName() {
+      return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/sql/expressions/conditions.js
+function bindIfParam(value, column) {
+  if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
+    return new Param(value, column);
+  }
+  return value;
+}
+function and(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== undefined);
+  if (conditions.length === 0) {
+    return;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" and ")),
+    new StringChunk(")")
+  ]);
+}
+function or(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== undefined);
+  if (conditions.length === 0) {
+    return;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" or ")),
+    new StringChunk(")")
+  ]);
+}
+function not(condition) {
+  return sql`not ${condition}`;
+}
+function inArray(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      return sql`false`;
+    }
+    return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
+  }
+  return sql`${column} in ${bindIfParam(values, column)}`;
+}
+function notInArray(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      return sql`true`;
+    }
+    return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
+  }
+  return sql`${column} not in ${bindIfParam(values, column)}`;
+}
+function isNull(value) {
+  return sql`${value} is null`;
+}
+function isNotNull(value) {
+  return sql`${value} is not null`;
+}
+function exists(subquery) {
+  return sql`exists ${subquery}`;
+}
+function notExists(subquery) {
+  return sql`not exists ${subquery}`;
+}
+function between(column, min, max) {
+  return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function notBetween(column, min, max) {
+  return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function like(column, value) {
+  return sql`${column} like ${value}`;
+}
+function notLike(column, value) {
+  return sql`${column} not like ${value}`;
+}
+function ilike(column, value) {
+  return sql`${column} ilike ${value}`;
+}
+function notIlike(column, value) {
+  return sql`${column} not ilike ${value}`;
+}
+function arrayContains(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      throw new Error("arrayContains requires at least one value");
+    }
+    const array = sql`${bindIfParam(values, column)}`;
+    return sql`${column} @> ${array}`;
+  }
+  return sql`${column} @> ${bindIfParam(values, column)}`;
+}
+function arrayContained(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      throw new Error("arrayContained requires at least one value");
+    }
+    const array = sql`${bindIfParam(values, column)}`;
+    return sql`${column} <@ ${array}`;
+  }
+  return sql`${column} <@ ${bindIfParam(values, column)}`;
+}
+function arrayOverlaps(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      throw new Error("arrayOverlaps requires at least one value");
+    }
+    const array = sql`${bindIfParam(values, column)}`;
+    return sql`${column} && ${array}`;
+  }
+  return sql`${column} && ${bindIfParam(values, column)}`;
+}
+var eq = (left, right) => {
+  return sql`${left} = ${bindIfParam(right, left)}`;
+}, ne = (left, right) => {
+  return sql`${left} <> ${bindIfParam(right, left)}`;
+}, gt = (left, right) => {
+  return sql`${left} > ${bindIfParam(right, left)}`;
+}, gte = (left, right) => {
+  return sql`${left} >= ${bindIfParam(right, left)}`;
+}, lt = (left, right) => {
+  return sql`${left} < ${bindIfParam(right, left)}`;
+}, lte = (left, right) => {
+  return sql`${left} <= ${bindIfParam(right, left)}`;
+};
+var init_conditions = __esm(() => {
+  init_column();
+  init_entity();
+  init_table();
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/expressions/select.js
+function asc(column) {
+  return sql`${column} asc`;
+}
+function desc(column) {
+  return sql`${column} desc`;
+}
+var init_select = __esm(() => {
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/expressions/index.js
+var init_expressions = __esm(() => {
+  init_conditions();
+  init_select();
+});
+
+// ../../../../node_modules/drizzle-orm/relations.js
+function getOperators() {
+  return {
+    and,
+    between,
+    eq,
+    exists,
+    gt,
+    gte,
+    ilike,
+    inArray,
+    isNull,
+    isNotNull,
+    like,
+    lt,
+    lte,
+    ne,
+    not,
+    notBetween,
+    notExists,
+    notLike,
+    notIlike,
+    notInArray,
+    or,
+    sql
+  };
+}
+function getOrderByOperators() {
+  return {
+    sql,
+    asc,
+    desc
+  };
+}
+function extractTablesRelationalConfig(schema, configHelpers) {
+  if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) {
+    schema = schema["default"];
+  }
+  const tableNamesMap = {};
+  const relationsBuffer = {};
+  const tablesConfig = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (is(value, Table)) {
+      const dbName = getTableUniqueName(value);
+      const bufferedRelations = relationsBuffer[dbName];
+      tableNamesMap[dbName] = key;
+      tablesConfig[key] = {
+        tsName: key,
+        dbName: value[Table.Symbol.Name],
+        schema: value[Table.Symbol.Schema],
+        columns: value[Table.Symbol.Columns],
+        relations: bufferedRelations?.relations ?? {},
+        primaryKey: bufferedRelations?.primaryKey ?? []
+      };
+      for (const column of Object.values(value[Table.Symbol.Columns])) {
+        if (column.primary) {
+          tablesConfig[key].primaryKey.push(column);
+        }
+      }
+      const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
+      if (extraConfig) {
+        for (const configEntry of Object.values(extraConfig)) {
+          if (is(configEntry, PrimaryKeyBuilder)) {
+            tablesConfig[key].primaryKey.push(...configEntry.columns);
+          }
+        }
+      }
+    } else if (is(value, Relations)) {
+      const dbName = getTableUniqueName(value.table);
+      const tableName = tableNamesMap[dbName];
+      const relations2 = value.config(configHelpers(value.table));
+      let primaryKey;
+      for (const [relationName, relation] of Object.entries(relations2)) {
+        if (tableName) {
+          const tableConfig = tablesConfig[tableName];
+          tableConfig.relations[relationName] = relation;
+          if (primaryKey) {
+            tableConfig.primaryKey.push(...primaryKey);
+          }
+        } else {
+          if (!(dbName in relationsBuffer)) {
+            relationsBuffer[dbName] = {
+              relations: {},
+              primaryKey
+            };
+          }
+          relationsBuffer[dbName].relations[relationName] = relation;
+        }
+      }
+    }
+  }
+  return { tables: tablesConfig, tableNamesMap };
+}
+function relations(table, relations2) {
+  return new Relations(table, (helpers) => Object.fromEntries(Object.entries(relations2(helpers)).map(([key, value]) => [
+    key,
+    value.withFieldName(key)
+  ])));
+}
+function createOne(sourceTable) {
+  return function one(table, config) {
+    return new One(sourceTable, table, config, config?.fields.reduce((res, f) => res && f.notNull, true) ?? false);
+  };
+}
+function createMany(sourceTable) {
+  return function many(referencedTable, config) {
+    return new Many(sourceTable, referencedTable, config);
+  };
+}
+function normalizeRelation(schema, tableNamesMap, relation) {
+  if (is(relation, One) && relation.config) {
+    return {
+      fields: relation.config.fields,
+      references: relation.config.references
+    };
+  }
+  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
+  if (!referencedTableTsName) {
+    throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
+  }
+  const referencedTableConfig = schema[referencedTableTsName];
+  if (!referencedTableConfig) {
+    throw new Error(`Table "${referencedTableTsName}" not found in schema`);
+  }
+  const sourceTable = relation.sourceTable;
+  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
+  if (!sourceTableTsName) {
+    throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
+  }
+  const reverseRelations = [];
+  for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) {
+    if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {
+      reverseRelations.push(referencedTableRelation);
+    }
+  }
+  if (reverseRelations.length > 1) {
+    throw relation.relationName ? new Error(`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`) : new Error(`There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`);
+  }
+  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
+    return {
+      fields: reverseRelations[0].config.references,
+      references: reverseRelations[0].config.fields
+    };
+  }
+  throw new Error(`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`);
+}
+function createTableRelationsHelpers(sourceTable) {
+  return {
+    one: createOne(sourceTable),
+    many: createMany(sourceTable)
+  };
+}
+function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
+  const result = {};
+  for (const [
+    selectionItemIndex,
+    selectionItem
+  ] of buildQueryResultSelection.entries()) {
+    if (selectionItem.isJson) {
+      const relation = tableConfig.relations[selectionItem.tsKey];
+      const rawSubRows = row[selectionItemIndex];
+      const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
+      result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue) : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
+    } else {
+      const value = mapColumnValue(row[selectionItemIndex]);
+      const field = selectionItem.field;
+      let decoder;
+      if (is(field, Column)) {
+        decoder = field;
+      } else if (is(field, SQL)) {
+        decoder = field.decoder;
+      } else {
+        decoder = field.sql.decoder;
+      }
+      result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
+    }
+  }
+  return result;
+}
+var Relation, Relations, One, Many;
+var init_relations = __esm(() => {
+  init_table();
+  init_column();
+  init_entity();
+  init_primary_keys();
+  init_expressions();
+  init_sql();
+  Relation = class Relation {
+    constructor(sourceTable, referencedTable, relationName) {
+      this.sourceTable = sourceTable;
+      this.referencedTable = referencedTable;
+      this.relationName = relationName;
+      this.referencedTableName = referencedTable[Table.Symbol.Name];
+    }
+    static [entityKind] = "Relation";
+    referencedTableName;
+    fieldName;
+  };
+  Relations = class Relations {
+    constructor(table, config) {
+      this.table = table;
+      this.config = config;
+    }
+    static [entityKind] = "Relations";
+  };
+  One = class One extends Relation {
+    constructor(sourceTable, referencedTable, config, isNullable) {
+      super(sourceTable, referencedTable, config?.relationName);
+      this.config = config;
+      this.isNullable = isNullable;
+    }
+    static [entityKind] = "One";
+    withFieldName(fieldName) {
+      const relation = new One(this.sourceTable, this.referencedTable, this.config, this.isNullable);
+      relation.fieldName = fieldName;
+      return relation;
+    }
+  };
+  Many = class Many extends Relation {
+    constructor(sourceTable, referencedTable, config) {
+      super(sourceTable, referencedTable, config?.relationName);
+      this.config = config;
+    }
+    static [entityKind] = "Many";
+    withFieldName(fieldName) {
+      const relation = new Many(this.sourceTable, this.referencedTable, this.config);
+      relation.fieldName = fieldName;
+      return relation;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/sql/functions/aggregate.js
+function count(expression) {
+  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
+}
+function countDistinct(expression) {
+  return sql`count(distinct ${expression})`.mapWith(Number);
+}
+function avg(expression) {
+  return sql`avg(${expression})`.mapWith(String);
+}
+function avgDistinct(expression) {
+  return sql`avg(distinct ${expression})`.mapWith(String);
+}
+function sum(expression) {
+  return sql`sum(${expression})`.mapWith(String);
+}
+function sumDistinct(expression) {
+  return sql`sum(distinct ${expression})`.mapWith(String);
+}
+function max(expression) {
+  return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
+}
+function min(expression) {
+  return sql`min(${expression})`.mapWith(is(expression, Column) ? expression : String);
+}
+var init_aggregate = __esm(() => {
+  init_column();
+  init_entity();
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/functions/vector.js
+function toSql(value) {
+  return JSON.stringify(value);
+}
+function l2Distance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <-> ${toSql(value)}`;
+  }
+  return sql`${column} <-> ${value}`;
+}
+function l1Distance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <+> ${toSql(value)}`;
+  }
+  return sql`${column} <+> ${value}`;
+}
+function innerProduct(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <#> ${toSql(value)}`;
+  }
+  return sql`${column} <#> ${value}`;
+}
+function cosineDistance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <=> ${toSql(value)}`;
+  }
+  return sql`${column} <=> ${value}`;
+}
+function hammingDistance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <~> ${toSql(value)}`;
+  }
+  return sql`${column} <~> ${value}`;
+}
+function jaccardDistance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <%> ${toSql(value)}`;
+  }
+  return sql`${column} <%> ${value}`;
+}
+var init_vector = __esm(() => {
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/functions/index.js
+var init_functions = __esm(() => {
+  init_aggregate();
+  init_vector();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/index.js
+var init_sql2 = __esm(() => {
+  init_expressions();
+  init_functions();
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/index.js
+var exports_drizzle_orm = {};
+__export(exports_drizzle_orm, {
+  textDecoder: () => textDecoder,
+  sumDistinct: () => sumDistinct,
+  sum: () => sum,
+  sql: () => sql,
+  relations: () => relations,
+  placeholder: () => placeholder,
+  param: () => param,
+  orderSelectedFields: () => orderSelectedFields,
+  or: () => or,
+  notLike: () => notLike,
+  notInArray: () => notInArray,
+  notIlike: () => notIlike,
+  notExists: () => notExists,
+  notBetween: () => notBetween,
+  not: () => not,
+  normalizeRelation: () => normalizeRelation,
+  noopMapper: () => noopMapper,
+  noopEncoder: () => noopEncoder,
+  noopDecoder: () => noopDecoder,
+  ne: () => ne,
+  name: () => name,
+  min: () => min,
+  max: () => max,
+  mapUpdateSet: () => mapUpdateSet,
+  mapResultRow: () => mapResultRow,
+  mapRelationalRow: () => mapRelationalRow,
+  mapColumnsInSQLToAlias: () => mapColumnsInSQLToAlias,
+  mapColumnsInAliasedSQLToAlias: () => mapColumnsInAliasedSQLToAlias,
+  lte: () => lte,
+  lt: () => lt,
+  like: () => like,
+  l2Distance: () => l2Distance,
+  l1Distance: () => l1Distance,
+  jaccardDistance: () => jaccardDistance,
+  isView: () => isView,
+  isTable: () => isTable,
+  isSQLWrapper: () => isSQLWrapper,
+  isNull: () => isNull,
+  isNotNull: () => isNotNull,
+  isDriverValueEncoder: () => isDriverValueEncoder,
+  isConfig: () => isConfig,
+  is: () => is,
+  innerProduct: () => innerProduct,
+  inArray: () => inArray,
+  ilike: () => ilike,
+  haveSameKeys: () => haveSameKeys,
+  hasOwnEntityKind: () => hasOwnEntityKind,
+  hammingDistance: () => hammingDistance,
+  gte: () => gte,
+  gt: () => gt,
+  getViewSelectedFields: () => getViewSelectedFields,
+  getViewName: () => getViewName,
+  getTableUniqueName: () => getTableUniqueName,
+  getTableName: () => getTableName,
+  getTableLikeName: () => getTableLikeName,
+  getTableColumns: () => getTableColumns,
+  getOrderByOperators: () => getOrderByOperators,
+  getOperators: () => getOperators,
+  getColumnNameAndConfig: () => getColumnNameAndConfig,
+  fillPlaceholders: () => fillPlaceholders,
+  extractTablesRelationalConfig: () => extractTablesRelationalConfig,
+  exists: () => exists,
+  eq: () => eq,
+  entityKind: () => entityKind,
+  desc: () => desc,
+  createTableRelationsHelpers: () => createTableRelationsHelpers,
+  createOne: () => createOne,
+  createMany: () => createMany,
+  countDistinct: () => countDistinct,
+  count: () => count,
+  cosineDistance: () => cosineDistance,
+  bindIfParam: () => bindIfParam,
+  between: () => between,
+  avgDistinct: () => avgDistinct,
+  avg: () => avg,
+  asc: () => asc,
+  arrayOverlaps: () => arrayOverlaps,
+  arrayContains: () => arrayContains,
+  arrayContained: () => arrayContained,
+  applyMixins: () => applyMixins,
+  and: () => and,
+  aliasedTableColumn: () => aliasedTableColumn,
+  aliasedTable: () => aliasedTable,
+  aliasedRelation: () => aliasedRelation,
+  WithSubquery: () => WithSubquery,
+  ViewBaseConfig: () => ViewBaseConfig,
+  View: () => View,
+  TransactionRollbackError: () => TransactionRollbackError,
+  TableAliasProxyHandler: () => TableAliasProxyHandler,
+  Table: () => Table,
+  Subquery: () => Subquery,
+  StringChunk: () => StringChunk,
+  Schema: () => Schema,
+  SQL: () => SQL,
+  Relations: () => Relations,
+  RelationTableAliasProxyHandler: () => RelationTableAliasProxyHandler,
+  Relation: () => Relation,
+  QueryPromise: () => QueryPromise,
+  Placeholder: () => Placeholder,
+  Param: () => Param,
+  OriginalName: () => OriginalName,
+  One: () => One,
+  NoopLogger: () => NoopLogger,
+  Name: () => Name,
+  Many: () => Many,
+  IsAlias: () => IsAlias,
+  FakePrimitiveParam: () => FakePrimitiveParam,
+  ExtraConfigColumns: () => ExtraConfigColumns,
+  ExtraConfigBuilder: () => ExtraConfigBuilder,
+  DrizzleQueryError: () => DrizzleQueryError,
+  DrizzleError: () => DrizzleError,
+  DefaultLogger: () => DefaultLogger,
+  ConsoleLogWriter: () => ConsoleLogWriter,
+  Columns: () => Columns,
+  ColumnBuilder: () => ColumnBuilder,
+  ColumnAliasProxyHandler: () => ColumnAliasProxyHandler,
+  Column: () => Column,
+  BaseName: () => BaseName
+});
+var init_drizzle_orm = __esm(() => {
+  init_alias();
+  init_column_builder();
+  init_column();
+  init_entity();
+  init_errors();
+  init_logger();
+  init_query_promise();
+  init_relations();
+  init_sql2();
+  init_subquery();
+  init_table();
+  init_utils();
+  init_view_common();
+});
+
+// TrajectoryLoggerService.ts
+import { logger as logger2, Service } from "@elizaos/core";
+import { v4 as uuidv4 } from "uuid";
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function asString(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value instanceof Date)
+    return value.toISOString();
+  return null;
+}
+function asIsoString(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  const asText = asString(value);
+  if (!asText)
+    return new Date(0).toISOString();
+  const parsed = new Date(asText);
+  if (Number.isNaN(parsed.getTime()))
+    return new Date(0).toISOString();
+  return parsed.toISOString();
+}
+function pickCell(row, ...keys) {
+  for (const key of keys) {
+    if (Object.hasOwn(row, key)) {
+      return row[key];
+    }
+  }
+  return;
+}
+function sqlLiteral(v) {
+  if (v === null || v === undefined)
+    return "NULL";
+  if (typeof v === "number")
+    return String(v);
+  if (typeof v === "boolean")
+    return v ? "TRUE" : "FALSE";
+  if (typeof v === "object")
+    return `'${JSON.stringify(v).replace(/'/g, "''")}'::jsonb`;
+  return `'${String(v).replace(/'/g, "''")}'`;
+}
+
+class TrajectoryLoggerService extends Service {
+  static serviceType = "trajectory_logger";
+  capabilityDescription = "Captures and persists LLM calls, provider accesses, and full trajectories for debugging, analysis, and RL training";
+  enabled = true;
+  initialized = false;
+  activeTrajectories = new Map;
+  activeStepIds = new Map;
+  stepToTrajectory = new Map;
+  static async start(runtime) {
+    const service = new TrajectoryLoggerService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async stop() {
+    this.enabled = false;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  async getSqlHelper() {
+    const drizzle = await Promise.resolve().then(() => (init_drizzle_orm(), exports_drizzle_orm));
+    return drizzle.sql;
+  }
+  async executeRawSql(sqlText) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      throw new Error("Database adapter not available");
+    }
+    const sqlHelper = await this.getSqlHelper();
+    const db = runtime.adapter.db;
+    const query = sqlHelper.raw(sqlText);
+    const result = await db.execute(query);
+    const rows = Array.isArray(result.rows) ? result.rows : [];
+    const columns = result.fields && Array.isArray(result.fields) ? result.fields.map((field) => field.name) : rows.length > 0 ? Object.keys(rows[0]) : [];
+    return { rows, columns };
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      logger2.warn("[trajectory-logger] No runtime adapter available, skipping initialization");
+      return;
+    }
+    await this.ensureTablesExist();
+    this.initialized = true;
+    logger2.info("[trajectory-logger] Trajectory logger service initialized");
+  }
+  async ensureTablesExist() {
+    await this.executeRawSql(`
+      CREATE TABLE IF NOT EXISTS trajectories (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'chat',
+        status TEXT NOT NULL DEFAULT 'active',
+        start_time BIGINT NOT NULL,
+        end_time BIGINT,
+        duration_ms BIGINT,
+        step_count INTEGER NOT NULL DEFAULT 0,
+        llm_call_count INTEGER NOT NULL DEFAULT 0,
+        provider_access_count INTEGER NOT NULL DEFAULT 0,
+        total_prompt_tokens INTEGER NOT NULL DEFAULT 0,
+        total_completion_tokens INTEGER NOT NULL DEFAULT 0,
+        total_reward REAL NOT NULL DEFAULT 0,
+        scenario_id TEXT,
+        episode_id TEXT,
+        batch_id TEXT,
+        group_index INTEGER,
+        steps_json JSONB NOT NULL DEFAULT '[]',
+        reward_components_json JSONB NOT NULL DEFAULT '{}',
+        metrics_json JSONB NOT NULL DEFAULT '{}',
+        metadata_json JSONB NOT NULL DEFAULT '{}',
+        is_training_data BOOLEAN NOT NULL DEFAULT FALSE,
+        is_evaluation BOOLEAN NOT NULL DEFAULT FALSE,
+        used_in_training BOOLEAN NOT NULL DEFAULT FALSE,
+        ai_judge_reward REAL,
+        ai_judge_reasoning TEXT,
+        judged_at TIMESTAMPTZ,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_agent_id ON trajectories(agent_id)`);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_source ON trajectories(source)`);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_status ON trajectories(status)`);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_created_at ON trajectories(created_at)`);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_scenario_id ON trajectories(scenario_id)`);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_batch_id ON trajectories(batch_id)`);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_is_training ON trajectories(is_training_data)`);
+  }
+  logLlmCall(params) {
+    if (!this.enabled)
+      return;
+    const trajectoryId = this.stepToTrajectory.get(params.stepId);
+    if (!trajectoryId) {
+      logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No active trajectory for LLM call");
+      return;
+    }
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory)
+      return;
+    const currentStepId = this.activeStepIds.get(trajectoryId);
+    const step = trajectory.steps.find((s) => s.stepId === currentStepId);
+    if (step) {
+      const llmCall = {
+        callId: uuidv4(),
+        timestamp: Date.now(),
+        model: params.model,
+        systemPrompt: params.systemPrompt,
+        userPrompt: params.userPrompt,
+        response: params.response,
+        temperature: params.temperature,
+        maxTokens: params.maxTokens,
+        purpose: params.purpose,
+        actionType: params.actionType,
+        promptTokens: params.promptTokens,
+        completionTokens: params.completionTokens,
+        latencyMs: params.latencyMs
+      };
+      step.llmCalls.push(llmCall);
+    }
+    this.updateTrajectoryCountsInMemory(trajectoryId, {
+      llmCallCount: 1,
+      promptTokens: params.promptTokens ?? 0,
+      completionTokens: params.completionTokens ?? 0
+    });
+  }
+  logProviderAccess(params) {
+    if (!this.enabled)
+      return;
+    const trajectoryId = this.stepToTrajectory.get(params.stepId);
+    if (!trajectoryId) {
+      logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No active trajectory for provider access");
+      return;
+    }
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory)
+      return;
+    const currentStepId = this.activeStepIds.get(trajectoryId);
+    const step = trajectory.steps.find((s) => s.stepId === currentStepId);
+    if (step) {
+      const access = {
+        providerId: uuidv4(),
+        providerName: params.providerName,
+        timestamp: Date.now(),
+        data: params.data,
+        query: params.query,
+        purpose: params.purpose
+      };
+      step.providerAccesses.push(access);
+    }
+  }
+  updateTrajectoryCountsInMemory(trajectoryId, counts) {}
+  async startTrajectory(stepId, options) {
+    if (!this.enabled)
+      return stepId;
+    const trajectoryId = uuidv4();
+    const now = Date.now();
+    const trajectory = {
+      trajectoryId,
+      agentId: options.agentId,
+      startTime: now,
+      endTime: now,
+      durationMs: 0,
+      scenarioId: options.scenarioId,
+      episodeId: options.episodeId,
+      batchId: options.batchId,
+      groupIndex: options.groupIndex,
+      steps: [],
+      totalReward: 0,
+      rewardComponents: { environmentReward: 0 },
+      metrics: {
+        episodeLength: 0,
+        finalStatus: "completed"
+      },
+      metadata: {
+        source: options.source ?? "chat",
+        roomId: options.roomId,
+        entityId: options.entityId,
+        ...options.metadata ?? {}
+      }
+    };
+    this.activeTrajectories.set(trajectoryId, trajectory);
+    this.stepToTrajectory.set(stepId, trajectoryId);
+    this.startStep(trajectoryId, {
+      timestamp: now,
+      agentBalance: 0,
+      agentPoints: 0,
+      agentPnL: 0,
+      openPositions: 0
+    });
+    try {
+      await this.executeRawSql(`
+        INSERT INTO trajectories (
+          id, agent_id, source, status, start_time, scenario_id, episode_id,
+          batch_id, group_index, metadata_json
+        ) VALUES (
+          ${sqlLiteral(trajectoryId)},
+          ${sqlLiteral(options.agentId)},
+          ${sqlLiteral(options.source ?? "chat")},
+          'active',
+          ${now},
+          ${sqlLiteral(options.scenarioId ?? null)},
+          ${sqlLiteral(options.episodeId ?? null)},
+          ${sqlLiteral(options.batchId ?? null)},
+          ${options.groupIndex ?? "NULL"},
+          ${sqlLiteral(trajectory.metadata)}
+        )
+      `);
+    } catch (err) {
+      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
+    }
+    return trajectoryId;
+  }
+  startStep(trajectoryId, envState) {
+    const stepId = uuidv4();
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger2.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
+      return stepId;
+    }
+    const step = {
+      stepId,
+      stepNumber: trajectory.steps.length,
+      timestamp: envState.timestamp || Date.now(),
+      environmentState: envState,
+      observation: {},
+      llmCalls: [],
+      providerAccesses: [],
+      action: {
+        attemptId: "",
+        timestamp: 0,
+        actionType: "pending",
+        actionName: "pending",
+        parameters: {},
+        success: false
+      },
+      reward: 0,
+      done: false
+    };
+    trajectory.steps.push(step);
+    this.activeStepIds.set(trajectoryId, stepId);
+    return stepId;
+  }
+  completeStep(trajectoryId, action, rewardInfo) {
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory)
+      return;
+    const stepId = this.activeStepIds.get(trajectoryId);
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step)
+      return;
+    step.action = {
+      attemptId: uuidv4(),
+      timestamp: Date.now(),
+      ...action
+    };
+    if (rewardInfo?.reward !== undefined) {
+      step.reward = rewardInfo.reward;
+      trajectory.totalReward += rewardInfo.reward;
+    }
+    if (rewardInfo?.components) {
+      trajectory.rewardComponents = {
+        ...trajectory.rewardComponents,
+        ...rewardInfo.components
+      };
+    }
+    this.activeStepIds.delete(trajectoryId);
+  }
+  async endTrajectory(stepIdOrTrajectoryId, status = "completed") {
+    if (!this.enabled)
+      return;
+    let trajectoryId = this.stepToTrajectory.get(stepIdOrTrajectoryId);
+    if (!trajectoryId) {
+      trajectoryId = stepIdOrTrajectoryId;
+    }
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger2.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No active trajectory to end");
+      return;
+    }
+    const now = Date.now();
+    trajectory.endTime = now;
+    trajectory.durationMs = now - trajectory.startTime;
+    trajectory.metrics.finalStatus = status;
+    trajectory.metrics.episodeLength = trajectory.steps.length;
+    let totalLlmCalls = 0;
+    let totalProviderAccesses = 0;
+    let totalPromptTokens = 0;
+    let totalCompletionTokens = 0;
+    for (const step of trajectory.steps) {
+      totalLlmCalls += step.llmCalls.length;
+      totalProviderAccesses += step.providerAccesses.length;
+      for (const call of step.llmCalls) {
+        totalPromptTokens += call.promptTokens ?? 0;
+        totalCompletionTokens += call.completionTokens ?? 0;
+      }
+    }
+    try {
+      await this.executeRawSql(`
+        UPDATE trajectories SET
+          status = ${sqlLiteral(status)},
+          end_time = ${now},
+          duration_ms = ${trajectory.durationMs},
+          step_count = ${trajectory.steps.length},
+          llm_call_count = ${totalLlmCalls},
+          provider_access_count = ${totalProviderAccesses},
+          total_prompt_tokens = ${totalPromptTokens},
+          total_completion_tokens = ${totalCompletionTokens},
+          total_reward = ${trajectory.totalReward},
+          steps_json = ${sqlLiteral(trajectory.steps)},
+          reward_components_json = ${sqlLiteral(trajectory.rewardComponents)},
+          metrics_json = ${sqlLiteral(trajectory.metrics)},
+          metadata_json = ${sqlLiteral(trajectory.metadata)},
+          updated_at = NOW()
+        WHERE id = ${sqlLiteral(trajectoryId)}
+      `);
+    } catch (err) {
+      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to persist trajectory end");
+    }
+    this.activeTrajectories.delete(trajectoryId);
+    this.activeStepIds.delete(trajectoryId);
+    for (const [stepId, trajId] of this.stepToTrajectory.entries()) {
+      if (trajId === trajectoryId) {
+        this.stepToTrajectory.delete(stepId);
+      }
+    }
+  }
+  async listTrajectories(options = {}) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      return { trajectories: [], total: 0, offset: 0, limit: 50 };
+    }
+    const offset = Math.max(0, options.offset ?? 0);
+    const limit = Math.min(500, Math.max(1, options.limit ?? 50));
+    const whereClauses = [];
+    if (options.status) {
+      whereClauses.push(`status = ${sqlLiteral(options.status)}`);
+    }
+    if (options.source) {
+      whereClauses.push(`source = ${sqlLiteral(options.source)}`);
+    }
+    if (options.scenarioId) {
+      whereClauses.push(`scenario_id = ${sqlLiteral(options.scenarioId)}`);
+    }
+    if (options.batchId) {
+      whereClauses.push(`batch_id = ${sqlLiteral(options.batchId)}`);
+    }
+    if (options.isTrainingData !== undefined) {
+      whereClauses.push(`is_training_data = ${options.isTrainingData}`);
+    }
+    if (options.startDate) {
+      whereClauses.push(`created_at >= ${sqlLiteral(options.startDate)}::timestamptz`);
+    }
+    if (options.endDate) {
+      whereClauses.push(`created_at <= ${sqlLiteral(options.endDate)}::timestamptz`);
+    }
+    if (options.search) {
+      const escaped = options.search.replace(/'/g, "''").replace(/%/g, "\\%");
+      whereClauses.push(`(
+        id ILIKE '%${escaped}%' OR
+        agent_id ILIKE '%${escaped}%' OR
+        source ILIKE '%${escaped}%' OR
+        scenario_id ILIKE '%${escaped}%'
+      )`);
+    }
+    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const countResult = await this.executeRawSql(`SELECT count(*)::int AS total FROM trajectories ${whereClause}`);
+    const total = asNumber(pickCell(countResult.rows[0] ?? {}, "total")) ?? 0;
+    const rowsResult = await this.executeRawSql(`
+      SELECT
+        id, agent_id, source, status, start_time, end_time, duration_ms,
+        step_count, llm_call_count, total_prompt_tokens, total_completion_tokens,
+        total_reward, scenario_id, batch_id, created_at
+      FROM trajectories
+      ${whereClause}
+      ORDER BY created_at DESC
+      LIMIT ${limit} OFFSET ${offset}
+    `);
+    const trajectories = rowsResult.rows.map((row) => ({
+      id: asString(pickCell(row, "id")) ?? "",
+      agentId: asString(pickCell(row, "agent_id")) ?? "",
+      source: asString(pickCell(row, "source")) ?? "chat",
+      status: asString(pickCell(row, "status")) ?? "completed",
+      startTime: asNumber(pickCell(row, "start_time")) ?? 0,
+      endTime: asNumber(pickCell(row, "end_time")),
+      durationMs: asNumber(pickCell(row, "duration_ms")),
+      stepCount: asNumber(pickCell(row, "step_count")) ?? 0,
+      llmCallCount: asNumber(pickCell(row, "llm_call_count")) ?? 0,
+      totalPromptTokens: asNumber(pickCell(row, "total_prompt_tokens")) ?? 0,
+      totalCompletionTokens: asNumber(pickCell(row, "total_completion_tokens")) ?? 0,
+      totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
+      scenarioId: asString(pickCell(row, "scenario_id")),
+      batchId: asString(pickCell(row, "batch_id")),
+      createdAt: asIsoString(pickCell(row, "created_at"))
+    }));
+    return { trajectories, total, offset, limit };
+  }
+  async getTrajectoryDetail(trajectoryId) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter)
+      return null;
+    const safeId = trajectoryId.replace(/'/g, "''");
+    const result = await this.executeRawSql(`SELECT * FROM trajectories WHERE id = '${safeId}' LIMIT 1`);
+    if (result.rows.length === 0)
+      return null;
+    const row = result.rows[0];
+    return this.rowToTrajectory(row);
+  }
+  async getStats() {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      return {
+        totalTrajectories: 0,
+        totalSteps: 0,
+        totalLlmCalls: 0,
+        totalPromptTokens: 0,
+        totalCompletionTokens: 0,
+        averageDurationMs: 0,
+        averageReward: 0,
+        bySource: {},
+        byStatus: {},
+        byScenario: {}
+      };
+    }
+    const statsResult = await this.executeRawSql(`
+      SELECT
+        count(*)::int AS total_trajectories,
+        COALESCE(sum(step_count), 0)::int AS total_steps,
+        COALESCE(sum(llm_call_count), 0)::int AS total_llm_calls,
+        COALESCE(sum(total_prompt_tokens), 0)::int AS total_prompt_tokens,
+        COALESCE(sum(total_completion_tokens), 0)::int AS total_completion_tokens,
+        COALESCE(avg(duration_ms), 0)::int AS avg_duration_ms,
+        COALESCE(avg(total_reward), 0)::real AS avg_reward
+      FROM trajectories
+    `);
+    const sourceResult = await this.executeRawSql(`
+      SELECT source, count(*)::int AS cnt
+      FROM trajectories
+      GROUP BY source
+    `);
+    const statusResult = await this.executeRawSql(`
+      SELECT status, count(*)::int AS cnt
+      FROM trajectories
+      GROUP BY status
+    `);
+    const scenarioResult = await this.executeRawSql(`
+      SELECT scenario_id, count(*)::int AS cnt
+      FROM trajectories
+      WHERE scenario_id IS NOT NULL
+      GROUP BY scenario_id
+    `);
+    const stats = statsResult.rows[0] ?? {};
+    const bySource = {};
+    const byStatus = {};
+    const byScenario = {};
+    for (const row of sourceResult.rows) {
+      const source = asString(pickCell(row, "source"));
+      const cnt = asNumber(pickCell(row, "cnt"));
+      if (source && cnt !== null)
+        bySource[source] = cnt;
+    }
+    for (const row of statusResult.rows) {
+      const status = asString(pickCell(row, "status"));
+      const cnt = asNumber(pickCell(row, "cnt"));
+      if (status && cnt !== null)
+        byStatus[status] = cnt;
+    }
+    for (const row of scenarioResult.rows) {
+      const scenario = asString(pickCell(row, "scenario_id"));
+      const cnt = asNumber(pickCell(row, "cnt"));
+      if (scenario && cnt !== null)
+        byScenario[scenario] = cnt;
+    }
+    return {
+      totalTrajectories: asNumber(pickCell(stats, "total_trajectories")) ?? 0,
+      totalSteps: asNumber(pickCell(stats, "total_steps")) ?? 0,
+      totalLlmCalls: asNumber(pickCell(stats, "total_llm_calls")) ?? 0,
+      totalPromptTokens: asNumber(pickCell(stats, "total_prompt_tokens")) ?? 0,
+      totalCompletionTokens: asNumber(pickCell(stats, "total_completion_tokens")) ?? 0,
+      averageDurationMs: asNumber(pickCell(stats, "avg_duration_ms")) ?? 0,
+      averageReward: asNumber(pickCell(stats, "avg_reward")) ?? 0,
+      bySource,
+      byStatus,
+      byScenario
+    };
+  }
+  async deleteTrajectories(trajectoryIds) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter)
+      return 0;
+    if (trajectoryIds.length === 0)
+      return 0;
+    const ids = trajectoryIds.map(sqlLiteral).join(", ");
+    const result = await this.executeRawSql(`DELETE FROM trajectories WHERE id IN (${ids}) RETURNING id`);
+    return result.rows.length;
+  }
+  async clearAllTrajectories() {
+    const runtime = this.runtime;
+    if (!runtime?.adapter)
+      return 0;
+    const countResult = await this.executeRawSql(`SELECT count(*)::int AS cnt FROM trajectories`);
+    const count2 = asNumber(pickCell(countResult.rows[0] ?? {}, "cnt")) ?? 0;
+    await this.executeRawSql(`DELETE FROM trajectories`);
+    return count2;
+  }
+  async exportTrajectories(options) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      throw new Error("Database not available");
+    }
+    const whereClauses = [];
+    if (options.trajectoryIds && options.trajectoryIds.length > 0) {
+      const ids = options.trajectoryIds.map(sqlLiteral).join(", ");
+      whereClauses.push(`id IN (${ids})`);
+    }
+    if (options.startDate) {
+      whereClauses.push(`created_at >= ${sqlLiteral(options.startDate)}::timestamptz`);
+    }
+    if (options.endDate) {
+      whereClauses.push(`created_at <= ${sqlLiteral(options.endDate)}::timestamptz`);
+    }
+    if (options.scenarioId) {
+      whereClauses.push(`scenario_id = ${sqlLiteral(options.scenarioId)}`);
+    }
+    if (options.batchId) {
+      whereClauses.push(`batch_id = ${sqlLiteral(options.batchId)}`);
+    }
+    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const result = await this.executeRawSql(`SELECT * FROM trajectories ${whereClause} ORDER BY created_at DESC`);
+    const trajectories = result.rows.map((row) => this.rowToTrajectory(row));
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    if (options.format === "csv") {
+      const lines = [
+        "id,agent_id,source,status,start_time,end_time,duration_ms,step_count,llm_call_count,total_reward,scenario_id"
+      ];
+      for (const t of trajectories) {
+        lines.push([
+          t.trajectoryId,
+          t.agentId,
+          t.metadata.source ?? "chat",
+          t.metrics.finalStatus,
+          t.startTime,
+          t.endTime,
+          t.durationMs,
+          t.steps.length,
+          t.steps.reduce((sum2, s) => sum2 + s.llmCalls.length, 0),
+          t.totalReward,
+          t.scenarioId ?? ""
+        ].join(","));
+      }
+      return {
+        data: lines.join(`
+`),
+        filename: `trajectories-${timestamp}.csv`,
+        mimeType: "text/csv"
+      };
+    }
+    let exportData = trajectories;
+    if (!options.includePrompts) {
+      exportData = trajectories.map((t) => ({
+        ...t,
+        steps: t.steps.map((s) => ({
+          ...s,
+          llmCalls: s.llmCalls.map((c) => ({
+            ...c,
+            systemPrompt: "[redacted]",
+            userPrompt: "[redacted]",
+            response: "[redacted]"
+          }))
+        }))
+      }));
+    }
+    return {
+      data: JSON.stringify(exportData, null, 2),
+      filename: `trajectories-${timestamp}.json`,
+      mimeType: "application/json"
+    };
+  }
+  rowToTrajectory(row) {
+    const parseJson = (cell, fallback) => {
+      if (typeof cell === "string") {
+        try {
+          return JSON.parse(cell);
+        } catch {
+          return fallback;
+        }
+      }
+      if (typeof cell === "object" && cell !== null && !Array.isArray(cell)) {
+        return cell;
+      }
+      return fallback;
+    };
+    return {
+      trajectoryId: asString(pickCell(row, "id")) ?? "",
+      agentId: asString(pickCell(row, "agent_id")) ?? "",
+      startTime: asNumber(pickCell(row, "start_time")) ?? 0,
+      endTime: asNumber(pickCell(row, "end_time")) ?? 0,
+      durationMs: asNumber(pickCell(row, "duration_ms")) ?? 0,
+      scenarioId: asString(pickCell(row, "scenario_id")) ?? undefined,
+      episodeId: asString(pickCell(row, "episode_id")) ?? undefined,
+      batchId: asString(pickCell(row, "batch_id")) ?? undefined,
+      groupIndex: asNumber(pickCell(row, "group_index")) ?? undefined,
+      steps: parseJson(pickCell(row, "steps_json"), []),
+      totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
+      rewardComponents: parseJson(pickCell(row, "reward_components_json"), { environmentReward: 0 }),
+      metrics: parseJson(pickCell(row, "metrics_json"), {
+        episodeLength: 0,
+        finalStatus: "completed"
+      }),
+      metadata: parseJson(pickCell(row, "metadata_json"), {})
+    };
+  }
+  getActiveTrajectory(trajectoryId) {
+    return this.activeTrajectories.get(trajectoryId) || null;
+  }
+  getCurrentStepId(trajectoryId) {
+    return this.activeStepIds.get(trajectoryId) || null;
+  }
+  getProviderAccessLogs() {
+    return [];
+  }
+  getLlmCallLogs() {
+    return [];
+  }
+}
 // action-interceptor.ts
-import { logger } from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
 var trajectoryContexts = new WeakMap;
 function setTrajectoryContext(runtime, trajectoryId, trajectoryLogger) {
   trajectoryContexts.set(runtime, { trajectoryId, logger: trajectoryLogger });
@@ -23,7 +2503,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger.warn({ action: action.name, trajectoryId }, "No active step for action execution");
+        logger3.warn({ action: action.name, trajectoryId }, "No active step for action execution");
         const result = await originalHandler(runtime, message, state, options, callback);
         return result ?? undefined;
       }
@@ -43,7 +2523,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       };
       const errorHandler = (err) => {
         const error = err instanceof Error ? err.message : typeof err === "string" ? err : err.message || String(err);
-        logger.error({ action: action.name, trajectoryId, error }, "Action execution failed");
+        logger3.error({ action: action.name, trajectoryId, error }, "Action execution failed");
         const stateSnapshot = state ? JSON.parse(JSON.stringify(state)) : null;
         loggerService.completeStep(trajectoryId, stepId, {
           actionType: action.name,
@@ -86,7 +2566,7 @@ function wrapPluginActions(plugin, trajectoryLogger) {
 function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger.warn({ trajectoryId }, "No active step for LLM call from action");
+    logger3.warn({ trajectoryId }, "No active step for LLM call from action");
     return;
   }
   trajectoryLogger.logLLMCall(stepId, {
@@ -107,7 +2587,7 @@ function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
 function logProviderFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger.warn({ trajectoryId }, "No active step for provider access from action");
+    logger3.warn({ trajectoryId }, "No active step for provider access from action");
     return;
   }
   trajectoryLogger.logProviderAccess(stepId, {
@@ -129,7 +2609,7 @@ function wrapProviderWithLogging(provider, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
+        logger3.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
         return originalGet?.(runtime, message, state) || { text: "" };
       }
       const result = await originalGet?.(runtime, message, state) || { text: "" };
@@ -331,14 +2811,14 @@ function toARTJSONL(trajectory) {
   return JSON.stringify(toARTTrajectory(trajectory));
 }
 function validateARTCompatibility(trajectory) {
-  const errors = [];
+  const errors2 = [];
   const warnings = [];
   if (trajectory.steps.length === 0) {
-    errors.push("Trajectory has no steps");
+    errors2.push("Trajectory has no steps");
   }
   for (const [idx, step] of trajectory.steps.entries()) {
     if (step.llmCalls.length === 0) {
-      errors.push(`Step ${idx} has no LLM calls - can't extract messages`);
+      errors2.push(`Step ${idx} has no LLM calls - can't extract messages`);
     }
     for (const llmCall of step.llmCalls) {
       if (!llmCall.userPrompt || llmCall.userPrompt.length < 10) {
@@ -350,15 +2830,15 @@ function validateARTCompatibility(trajectory) {
     }
   }
   if (trajectory.totalReward === undefined || Number.isNaN(trajectory.totalReward)) {
-    errors.push("Trajectory has no valid reward");
+    errors2.push("Trajectory has no valid reward");
   }
   const artTraj = toARTTrajectory(trajectory);
   if (artTraj.messages.length < 2) {
     warnings.push("Trajectory converts to very few messages (< 2)");
   }
   return {
-    valid: errors.length === 0,
-    errors,
+    valid: errors2.length === 0,
+    errors: errors2,
     warnings
   };
 }
@@ -454,7 +2934,7 @@ async function buildGameStateFromDB(_trajectoryId) {
 }
 async function recomputeTrajectoryRewards(_trajectoryIds) {}
 // integration.ts
-import { logger as logger2 } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 function startAutonomousTick(trajectoryLogger, context) {
   const trajectoryId = trajectoryLogger.startTrajectory(context.agentId, {
     scenarioId: context.scenarioId,
@@ -470,17 +2950,17 @@ function startAutonomousTick(trajectoryLogger, context) {
     openPositions: 0
   };
   trajectoryLogger.startStep(trajectoryId, envState);
-  logger2.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
+  logger4.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
   return trajectoryId;
 }
 async function endAutonomousTick(trajectoryLogger, trajectoryId, status = "completed", finalMetrics) {
   await trajectoryLogger.endTrajectory(trajectoryId, status, finalMetrics);
-  logger2.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
+  logger4.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
 }
 async function loggedLLMCall(trajectoryLogger, trajectoryId, options, llmCallFn) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger2.warn({ trajectoryId }, "No active step for LLM call");
+    logger4.warn({ trajectoryId }, "No active step for LLM call");
     const result2 = await llmCallFn();
     return result2.text;
   }
@@ -585,13 +3065,13 @@ class RewardService {
     return (score + 1) / 2;
   }
   normalizeScoresForGroup(scores) {
-    const min = Math.min(...scores);
-    const max = Math.max(...scores);
-    const range = max - min;
+    const min2 = Math.min(...scores);
+    const max2 = Math.max(...scores);
+    const range = max2 - min2;
     if (range === 0) {
       return scores.map(() => 0.5);
     }
-    return scores.map((s) => (s - min) / range);
+    return scores.map((s) => (s - min2) / range);
   }
 }
 function createRewardService(options = {}) {
@@ -605,197 +3085,13 @@ async function scoreTrajectoryGroup(trajectories) {
   const service = new RewardService;
   return service.scoreTrajectoryGroup(trajectories);
 }
-// TrajectoryLoggerService.ts
-import { asUUID, logger as logger3 } from "@elizaos/core";
-import { v4 as uuidv4 } from "uuid";
-
-class TrajectoryLoggerService {
-  activeTrajectories = new Map;
-  activeStepIds = new Map;
-  startTrajectory(agentId, options = {}) {
-    const trajectoryId = uuidv4();
-    const now = Date.now();
-    const trajectory = {
-      trajectoryId: asUUID(trajectoryId),
-      agentId: asUUID(agentId),
-      startTime: now,
-      endTime: now,
-      durationMs: 0,
-      episodeId: options.episodeId,
-      scenarioId: options.scenarioId,
-      batchId: options.batchId,
-      groupIndex: options.groupIndex,
-      steps: [],
-      totalReward: 0,
-      rewardComponents: {
-        environmentReward: 0
-      },
-      metrics: {
-        episodeLength: 0,
-        finalStatus: "completed"
-      },
-      metadata: options.metadata || {}
-    };
-    this.activeTrajectories.set(trajectoryId, trajectory);
-    return trajectoryId;
-  }
-  startStep(trajectoryId, envState) {
-    const stepId = uuidv4();
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory) {
-      throw new Error(`Trajectory ${trajectoryId} not found`);
-    }
-    const step = {
-      stepId: asUUID(stepId),
-      stepNumber: trajectory.steps.length,
-      timestamp: envState.timestamp || Date.now(),
-      environmentState: envState,
-      observation: {},
-      llmCalls: [],
-      providerAccesses: [],
-      action: {
-        attemptId: "",
-        timestamp: 0,
-        actionType: "pending",
-        actionName: "pending",
-        parameters: {},
-        success: false
-      },
-      reward: 0,
-      done: false
-    };
-    trajectory.steps.push(step);
-    this.activeStepIds.set(trajectoryId, stepId);
-    return stepId;
-  }
-  logLLMCall(stepId, llmCall) {
-    const trajectory = this.findTrajectoryByStepId(stepId);
-    if (!trajectory) {
-      logger3.warn({ stepId }, "Trajectory not found for LLM call");
-      return;
-    }
-    const step = trajectory.steps.find((s) => s.stepId === stepId);
-    if (!step) {
-      logger3.warn({ stepId }, "Step not found for LLM call");
-      return;
-    }
-    const fullLLMCall = {
-      callId: uuidv4(),
-      timestamp: Date.now(),
-      ...llmCall
-    };
-    step.llmCalls.push(fullLLMCall);
-  }
-  logProviderAccess(stepId, access) {
-    const trajectory = this.findTrajectoryByStepId(stepId);
-    if (!trajectory) {
-      logger3.warn({ stepId }, "Trajectory not found for provider access");
-      return;
-    }
-    const step = trajectory.steps.find((s) => s.stepId === stepId);
-    if (!step) {
-      logger3.warn({ stepId }, "Step not found for provider access");
-      return;
-    }
-    const fullAccess = {
-      providerId: uuidv4(),
-      timestamp: Date.now(),
-      ...access
-    };
-    step.providerAccesses.push(fullAccess);
-  }
-  logLLMCallByTrajectoryId(trajectoryId, llmCall) {
-    const stepId = this.activeStepIds.get(trajectoryId);
-    if (!stepId) {
-      logger3.warn({ trajectoryId }, "No active step for trajectory");
-      return;
-    }
-    this.logLLMCall(stepId, llmCall);
-  }
-  logProviderAccessByTrajectoryId(trajectoryId, access) {
-    const stepId = this.activeStepIds.get(trajectoryId);
-    if (!stepId) {
-      logger3.warn({ trajectoryId }, "No active step for trajectory");
-      return;
-    }
-    this.logProviderAccess(stepId, access);
-  }
-  getCurrentStepId(trajectoryId) {
-    return this.activeStepIds.get(trajectoryId) || null;
-  }
-  completeStep(trajectoryId, stepId, action, rewardInfo) {
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory) {
-      logger3.warn({ trajectoryId }, "Trajectory not found for completeStep");
-      return;
-    }
-    const step = trajectory.steps.find((s) => s.stepId === stepId);
-    if (!step) {
-      logger3.warn({ trajectoryId, stepId }, "Step not found for completeStep");
-      return;
-    }
-    step.action = {
-      attemptId: uuidv4(),
-      timestamp: Date.now(),
-      ...action
-    };
-    if (rewardInfo?.reward !== undefined) {
-      step.reward = rewardInfo.reward;
-      trajectory.totalReward += rewardInfo.reward;
-    }
-    if (rewardInfo?.components) {
-      trajectory.rewardComponents = {
-        ...trajectory.rewardComponents,
-        ...rewardInfo.components
-      };
-    }
-    this.activeStepIds.delete(trajectoryId);
-  }
-  completeCurrentStep(trajectoryId, action, rewardInfo) {
-    const stepId = this.activeStepIds.get(trajectoryId);
-    if (!stepId) {
-      logger3.warn({ trajectoryId }, "No active step for trajectory");
-      return;
-    }
-    this.completeStep(trajectoryId, stepId, action, rewardInfo);
-  }
-  async endTrajectory(trajectoryId, status, finalMetrics) {
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory) {
-      logger3.warn({ trajectoryId }, "Trajectory not found for endTrajectory");
-      return;
-    }
-    trajectory.endTime = Date.now();
-    trajectory.durationMs = trajectory.endTime - trajectory.startTime;
-    trajectory.metrics.finalStatus = status;
-    trajectory.metrics.episodeLength = trajectory.steps.length;
-    if (finalMetrics) {
-      trajectory.metrics = {
-        ...trajectory.metrics,
-        ...finalMetrics
-      };
-    }
-    this.activeStepIds.delete(trajectoryId);
-  }
-  getActiveTrajectory(trajectoryId) {
-    return this.activeTrajectories.get(trajectoryId) || null;
-  }
-  findTrajectoryByStepId(stepId) {
-    for (const trajectory of this.activeTrajectories.values()) {
-      if (trajectory.steps.some((s) => s.stepId === stepId)) {
-        return trajectory;
-      }
-    }
-    return null;
-  }
-}
 
 // index.ts
 var trajectoryLoggerPlugin = {
   name: "@elizaos/plugin-trajectory-logger",
-  description: "Collects complete agent interaction trajectory data for RL training. Records LLM calls, provider access, actions, environment state, and computes rewards.",
-  dependencies: [],
-  services: []
+  description: "Captures and persists complete agent interaction trajectories for debugging, analysis, and RL training. " + "Records LLM calls, provider accesses, actions, environment state, and computes rewards.",
+  dependencies: ["@elizaos/plugin-sql"],
+  services: [TrajectoryLoggerService]
 };
 var typescript_default = trajectoryLoggerPlugin;
 export {
@@ -838,4 +3134,4 @@ export {
   RewardService
 };
 
-//# debugId=8E8ACF830258000B64756E2164756E21
+//# debugId=61D715423871574264756E2164756E21