@elizaos/plugin-trajectory-logger 2.0.0-alpha.11 → 2.0.0-alpha.13

package/dist/node/index.node.js

@@ -1,3064 +1,193 @@
-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();
-});
-
 // index.ts
-import {
-  createUniqueUuid
-} from "@elizaos/core";
-import crypto from "node:crypto";
+import { createUniqueUuid } from "@elizaos/core";
 
 // TrajectoryLoggerService.ts
-import { logger as logger2, Service } from "@elizaos/core";
+import { asUUID, logger } 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, "''")}'`;
-  return `'${String(v).replace(/'/g, "''")}'`;
-}
 
-class TrajectoryLoggerService extends Service {
-  static serviceType = "trajectory_logger";
-  get serviceType() {
-    return TrajectoryLoggerService.serviceType;
-  }
-  capabilityDescription = "Captures and persists LLM calls, provider accesses, and full trajectories for debugging, analysis, and RL training";
-  enabled = true;
-  initialized = false;
+class TrajectoryLoggerService {
+  activeTrajectories = new Map;
   activeStepIds = new Map;
-  stepToTrajectory = new Map;
-  writeQueues = new Map;
-  static async start(runtime) {
-    const service = new this(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();
-    await this.backfillTrajectoriesMissingLlmCalls();
-    this.initialized = true;
-    logger2.info("[trajectory-logger] Trajectory logger service initialized");
-  }
-  async getTableColumnNames(tableName) {
-    const names = new Set;
-    try {
-      const result = await this.executeRawSql(`
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_name = ${sqlLiteral(tableName)}
-          AND table_schema NOT IN ('pg_catalog', 'information_schema')
-      `);
-      for (const row of result.rows) {
-        const name2 = asString(pickCell(row, "column_name"));
-        if (name2)
-          names.add(name2);
-      }
-      if (names.size > 0)
-        return names;
-    } catch {}
-    const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, "");
-    if (!safeTableName)
-      return names;
-    try {
-      const pragma = await this.executeRawSql(`PRAGMA table_info(${safeTableName})`);
-      for (const row of pragma.rows) {
-        const name2 = asString(pickCell(row, "name"));
-        if (name2)
-          names.add(name2);
-      }
-    } catch {}
-    return names;
-  }
-  async ensureTrajectoryColumnsExist() {
-    const columns = await this.getTableColumnNames("trajectories");
-    const requiredColumns = [
-      ["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"],
-      ["judged_at", "TIMESTAMPTZ"]
-    ];
-    for (const [columnName, definition] of requiredColumns) {
-      if (columns.has(columnName))
-        continue;
-      try {
-        await this.executeRawSql(`
-          ALTER TABLE trajectories
-          ADD COLUMN IF NOT EXISTS ${columnName} ${definition}
-        `);
-      } catch (errWithIfExists) {
-        try {
-          await this.executeRawSql(`
-            ALTER TABLE trajectories
-            ADD COLUMN ${columnName} ${definition}
-          `);
-        } catch (errPlain) {
-          const combinedMessage = `${errWithIfExists instanceof Error ? errWithIfExists.message : String(errWithIfExists)} | ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`.toLowerCase();
-          if (combinedMessage.includes("already exists") || combinedMessage.includes("duplicate column") || combinedMessage.includes("duplicate_column")) {
-            continue;
-          }
-          logger2.warn(`[trajectory-logger] Failed to add trajectories.${columnName} (non-fatal): ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`);
-        }
-      }
-    }
-    for (const statement of [
-      `ALTER TABLE trajectories
-       ALTER COLUMN start_time TYPE BIGINT USING start_time::BIGINT`,
-      `ALTER TABLE trajectories
-       ALTER COLUMN end_time TYPE BIGINT USING end_time::BIGINT`,
-      `ALTER TABLE trajectories
-       ALTER COLUMN duration_ms TYPE BIGINT USING duration_ms::BIGINT`
-    ]) {
-      try {
-        await this.executeRawSql(statement);
-      } catch {}
-    }
-  }
-  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 CURRENT_TIMESTAMP,
-        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await this.ensureTrajectoryColumnsExist();
-    try {
-      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)`);
-    } catch (e) {
-      logger2.warn(`[trajectory-logger] Failed to create indexes (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
-    }
-    await this.executeRawSql(`
-      CREATE TABLE IF NOT EXISTS trajectory_step_index (
-        step_id TEXT PRIMARY KEY,
-        trajectory_id TEXT NOT NULL REFERENCES trajectories(id) ON DELETE CASCADE,
-        step_number INTEGER NOT NULL DEFAULT 0,
-        is_active BOOLEAN NOT NULL DEFAULT FALSE,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectory_step_index_trajectory_id ON trajectory_step_index(trajectory_id)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectory_step_index_is_active ON trajectory_step_index(is_active)`);
-  }
-  normalizeTrajectoryStatus(value) {
-    switch (value) {
-      case "active":
-      case "completed":
-      case "error":
-      case "timeout":
-      case "terminated":
-        return value;
-      default:
-        return "completed";
-    }
-  }
-  async backfillTrajectoriesMissingLlmCalls() {
-    const maxRows = 2000;
-    let fixed = 0;
-    try {
-      const rows = await this.executeRawSql(`
-        SELECT id, status
-        FROM trajectories
-        WHERE COALESCE(llm_call_count, 0) = 0
-          AND status <> 'active'
-        ORDER BY created_at ASC
-        LIMIT ${maxRows}
-      `);
-      for (const row of rows.rows) {
-        const trajectoryId = asString(pickCell(row, "id"));
-        if (!trajectoryId)
-          continue;
-        const status = this.normalizeTrajectoryStatus(asString(pickCell(row, "status")));
-        await this.withTrajectoryWriteLock(trajectoryId, async () => {
-          const trajectory = await this.getTrajectoryById(trajectoryId);
-          if (!trajectory)
-            return;
-          const inserted = this.ensureAtLeastOneLlmCall(trajectory, "backfill");
-          if (!inserted)
-            return;
-          await this.persistTrajectory(trajectoryId, trajectory, status);
-          fixed += 1;
-        });
-      }
-      if (fixed > 0) {
-        logger2.info(`[trajectory-logger] Backfilled ${fixed} completed trajectories with synthetic LLM calls`);
-      }
-      if (rows.rows.length >= maxRows) {
-        logger2.warn(`[trajectory-logger] Backfill hit safety cap (${maxRows}); remaining older trajectories will be fixed lazily when touched`);
-      }
-    } catch (err) {
-      logger2.warn(`[trajectory-logger] Failed to backfill trajectories missing LLM calls (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  normalizePurpose(value) {
-    switch (value) {
-      case "action":
-      case "reasoning":
-      case "evaluation":
-      case "response":
-      case "other":
-        return value;
-      default:
-        return "other";
-    }
-  }
-  defaultEnvironmentState(timestamp = Date.now()) {
-    return {
-      timestamp,
-      agentBalance: 0,
-      agentPoints: 0,
-      agentPnL: 0,
-      openPositions: 0
-    };
-  }
-  createPendingAction(stepTimestamp) {
-    return {
-      attemptId: "",
-      timestamp: stepTimestamp,
-      actionType: "pending",
-      actionName: "pending",
-      parameters: {},
-      success: false
-    };
-  }
-  createStep(stepId, stepNumber, envState) {
-    const timestamp = envState.timestamp || Date.now();
-    return {
-      stepId,
-      stepNumber,
-      timestamp,
-      environmentState: envState,
-      observation: {},
-      llmCalls: [],
-      providerAccesses: [],
-      action: this.createPendingAction(timestamp),
-      reward: 0,
-      done: false
-    };
-  }
-  ensureAtLeastOneLlmCall(trajectory, source) {
-    if (this.computeTotals(trajectory.steps).llmCallCount > 0) {
-      return false;
-    }
-    const timestamp = Date.now();
-    let step = trajectory.steps[trajectory.steps.length - 1];
-    if (!step) {
-      step = this.createStep(uuidv4(), 0, this.defaultEnvironmentState(timestamp));
-      step.done = true;
-      trajectory.steps.push(step);
-    }
-    if (!Array.isArray(step.llmCalls)) {
-      step.llmCalls = [];
-    }
-    const syntheticCall = {
-      callId: uuidv4(),
-      timestamp,
-      model: "milady/synthetic-trajectory-fallback",
-      systemPrompt: "[synthetic] inserted by trajectory logger because no LLM calls were captured",
-      userPrompt: "[synthetic] this trajectory completed without recorded model activity",
-      response: "[synthetic] placeholder call inserted to enforce minimum llm_call_count=1",
-      temperature: 0,
-      maxTokens: 0,
-      promptTokens: 0,
-      completionTokens: 0,
-      latencyMs: 0,
-      purpose: "other",
-      actionType: "TRAJECTORY_FALLBACK"
-    };
-    step.llmCalls.push(syntheticCall);
-    if (!step.metadata)
-      step.metadata = {};
-    step.metadata.syntheticLlmCall = true;
-    step.metadata.syntheticLlmCallSource = source;
-    trajectory.metadata.syntheticLlmCall = true;
-    trajectory.metadata.syntheticLlmCallSource = source;
-    const existingFallbackCount = trajectory.metrics.syntheticLlmFallbackCount;
-    trajectory.metrics.syntheticLlmFallbackCount = typeof existingFallbackCount === "number" && Number.isFinite(existingFallbackCount) ? existingFallbackCount + 1 : 1;
-    return true;
-  }
-  computeTotals(steps) {
-    let llmCallCount = 0;
-    let providerAccessCount = 0;
-    let totalPromptTokens = 0;
-    let totalCompletionTokens = 0;
-    for (const step of steps) {
-      const llmCalls = Array.isArray(step.llmCalls) ? step.llmCalls : [];
-      const providerAccesses = Array.isArray(step.providerAccesses) ? step.providerAccesses : [];
-      llmCallCount += llmCalls.length;
-      providerAccessCount += providerAccesses.length;
-      for (const call of llmCalls) {
-        totalPromptTokens += call.promptTokens ?? 0;
-        totalCompletionTokens += call.completionTokens ?? 0;
-      }
-    }
-    return {
-      stepCount: steps.length,
-      llmCallCount,
-      providerAccessCount,
-      totalPromptTokens,
-      totalCompletionTokens
-    };
-  }
-  async withTrajectoryWriteLock(trajectoryId, task) {
-    const previous = this.writeQueues.get(trajectoryId) ?? Promise.resolve();
-    const next = previous.catch(() => {}).then(task);
-    this.writeQueues.set(trajectoryId, next);
-    try {
-      await next;
-    } finally {
-      if (this.writeQueues.get(trajectoryId) === next) {
-        this.writeQueues.delete(trajectoryId);
-      }
-    }
-  }
-  async getTrajectoryById(trajectoryId) {
-    const result = await this.executeRawSql(`SELECT * FROM trajectories WHERE id = ${sqlLiteral(trajectoryId)} LIMIT 1`);
-    if (result.rows.length === 0)
-      return null;
-    return this.rowToTrajectory(result.rows[0]);
-  }
-  async getStepIndex(stepId) {
-    const result = await this.executeRawSql(`SELECT trajectory_id, step_number, is_active FROM trajectory_step_index WHERE step_id = ${sqlLiteral(stepId)} LIMIT 1`);
-    const row = result.rows[0];
-    if (!row)
-      return null;
-    const trajectoryId = asString(pickCell(row, "trajectory_id"));
-    if (!trajectoryId)
-      return null;
-    const stepNumber = asNumber(pickCell(row, "step_number")) ?? 0;
-    const isActiveText = asString(pickCell(row, "is_active"));
-    const isActive = isActiveText === "true" || isActiveText === "t" || pickCell(row, "is_active") === true;
-    return { trajectoryId, stepNumber, isActive };
-  }
-  async setStepIndex(stepId, trajectoryId, stepNumber, isActive) {
-    await this.executeRawSql(`
-      INSERT INTO trajectory_step_index (
-        step_id, trajectory_id, step_number, is_active, updated_at
-      ) VALUES (
-        ${sqlLiteral(stepId)},
-        ${sqlLiteral(trajectoryId)},
-        ${stepNumber},
-        ${isActive ? "TRUE" : "FALSE"},
-        CURRENT_TIMESTAMP
-      )
-      ON CONFLICT (step_id) DO UPDATE SET
-        trajectory_id = EXCLUDED.trajectory_id,
-        step_number = EXCLUDED.step_number,
-        is_active = EXCLUDED.is_active,
-        updated_at = CURRENT_TIMESTAMP
-    `);
-  }
-  async markAllStepsInactive(trajectoryId) {
-    await this.executeRawSql(`
-      UPDATE trajectory_step_index
-      SET is_active = FALSE, updated_at = CURRENT_TIMESTAMP
-      WHERE trajectory_id = ${sqlLiteral(trajectoryId)}
-    `);
-  }
-  async resolveTrajectoryId(stepIdOrTrajectoryId) {
-    const cached = this.stepToTrajectory.get(stepIdOrTrajectoryId);
-    if (cached)
-      return cached;
-    const byStep = await this.getStepIndex(stepIdOrTrajectoryId);
-    if (byStep?.trajectoryId) {
-      this.stepToTrajectory.set(stepIdOrTrajectoryId, byStep.trajectoryId);
-      return byStep.trajectoryId;
-    }
-    const byId = await this.executeRawSql(`SELECT id FROM trajectories WHERE id = ${sqlLiteral(stepIdOrTrajectoryId)} LIMIT 1`);
-    const row = byId.rows[0];
-    const id = row ? asString(pickCell(row, "id")) : null;
-    return id;
-  }
-  async getCurrentStepIdFromDb(trajectoryId) {
-    const result = await this.executeRawSql(`
-      SELECT step_id
-      FROM trajectory_step_index
-      WHERE trajectory_id = ${sqlLiteral(trajectoryId)} AND is_active = TRUE
-      ORDER BY step_number DESC, updated_at DESC
-      LIMIT 1
-    `);
-    const row = result.rows[0];
-    return row ? asString(pickCell(row, "step_id")) : null;
-  }
-  async persistTrajectory(trajectoryId, trajectory, status = "active") {
-    if (status !== "active") {
-      this.ensureAtLeastOneLlmCall(trajectory, "finalize");
-    }
-    const totals = this.computeTotals(trajectory.steps);
-    const isFinalStatus = status !== "active";
-    const persistedEndTime = isFinalStatus ? trajectory.endTime : null;
-    const persistedDuration = isFinalStatus ? trajectory.durationMs : null;
-    const updatedAtIso = new Date().toISOString();
-    try {
-      await this.executeRawSql(`
-        UPDATE trajectories SET
-          status = ${sqlLiteral(status)},
-          end_time = ${sqlLiteral(persistedEndTime)},
-          duration_ms = ${sqlLiteral(persistedDuration)},
-          step_count = ${totals.stepCount},
-          llm_call_count = ${totals.llmCallCount},
-          provider_access_count = ${totals.providerAccessCount},
-          total_prompt_tokens = ${totals.totalPromptTokens},
-          total_completion_tokens = ${totals.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 = ${sqlLiteral(updatedAtIso)}
-        WHERE id = ${sqlLiteral(trajectoryId)}
-      `);
-    } catch (modernErr) {
-      await this.executeRawSql(`
-        UPDATE trajectories SET
-          status = ${sqlLiteral(status)},
-          end_time = ${sqlLiteral(persistedEndTime)},
-          duration_ms = ${sqlLiteral(persistedDuration)},
-          step_count = ${totals.stepCount},
-          llm_call_count = ${totals.llmCallCount},
-          provider_access_count = ${totals.providerAccessCount},
-          total_prompt_tokens = ${totals.totalPromptTokens},
-          total_completion_tokens = ${totals.totalCompletionTokens},
-          total_reward = ${trajectory.totalReward},
-          steps_json = ${sqlLiteral(trajectory.steps)},
-          metadata = ${sqlLiteral(trajectory.metadata)},
-          updated_at = ${sqlLiteral(updatedAtIso)}
-        WHERE id = ${sqlLiteral(trajectoryId)}
-      `).catch((legacyErr) => {
-        logger2.warn({ err: legacyErr, trajectoryId }, `[trajectory-logger] Failed to persist trajectory update after compatibility fallback: ${modernErr instanceof Error ? modernErr.message : String(modernErr)}`);
-        throw legacyErr;
-      });
-    }
-  }
-  async ensureStepExists(trajectory, stepId) {
-    let step = trajectory.steps.find((entry) => entry.stepId === stepId);
-    if (step) {
-      if (!Array.isArray(step.llmCalls))
-        step.llmCalls = [];
-      if (!Array.isArray(step.providerAccesses))
-        step.providerAccesses = [];
-      return step;
-    }
-    const index = await this.getStepIndex(stepId);
-    const stepNumber = index?.stepNumber ?? trajectory.steps.length;
-    step = this.createStep(stepId, stepNumber, this.defaultEnvironmentState());
-    trajectory.steps.push(step);
-    trajectory.steps.sort((a, b) => a.stepNumber - b.stepNumber);
-    return step;
-  }
-  logLlmCall(params) {
-    if (!this.enabled)
-      return;
-    (async () => {
-      const trajectoryId = await this.resolveTrajectoryId(params.stepId);
-      if (!trajectoryId) {
-        logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for LLM call");
-        return;
-      }
-      await this.withTrajectoryWriteLock(trajectoryId, async () => {
-        const trajectory = await this.getTrajectoryById(trajectoryId);
-        if (!trajectory)
-          return;
-        const step = await this.ensureStepExists(trajectory, params.stepId);
-        const llmCall = {
-          callId: uuidv4(),
-          timestamp: Date.now(),
-          model: params.model,
-          modelVersion: params.modelVersion,
-          systemPrompt: params.systemPrompt,
-          userPrompt: params.userPrompt,
-          response: params.response,
-          reasoning: params.reasoning,
-          temperature: params.temperature,
-          maxTokens: params.maxTokens,
-          purpose: this.normalizePurpose(params.purpose),
-          actionType: params.actionType,
-          promptTokens: params.promptTokens,
-          completionTokens: params.completionTokens,
-          latencyMs: params.latencyMs
-        };
-        step.llmCalls.push(llmCall);
-        await this.persistTrajectory(trajectoryId, trajectory, "active");
-      });
-    })().catch((err) => {
-      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist LLM call");
-    });
-  }
-  logLLMCall(stepId, details) {
-    this.logLlmCall({
-      stepId,
-      model: details.model,
-      modelVersion: details.modelVersion,
-      systemPrompt: details.systemPrompt,
-      userPrompt: details.userPrompt,
-      response: details.response,
-      reasoning: details.reasoning,
-      temperature: details.temperature,
-      maxTokens: details.maxTokens,
-      purpose: details.purpose,
-      actionType: details.actionType ?? "",
-      latencyMs: details.latencyMs ?? 0,
-      promptTokens: details.promptTokens,
-      completionTokens: details.completionTokens
-    });
-  }
-  logProviderAccess(arg1, arg2) {
-    if (!this.enabled)
-      return;
-    const params = typeof arg1 === "string" ? {
-      stepId: arg1,
-      providerName: arg2?.providerName ?? "unknown",
-      data: arg2?.data ?? {},
-      purpose: arg2?.purpose ?? "other",
-      query: arg2?.query
-    } : arg1;
-    (async () => {
-      const trajectoryId = await this.resolveTrajectoryId(params.stepId);
-      if (!trajectoryId) {
-        logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for provider access");
-        return;
-      }
-      await this.withTrajectoryWriteLock(trajectoryId, async () => {
-        const trajectory = await this.getTrajectoryById(trajectoryId);
-        if (!trajectory)
-          return;
-        const step = await this.ensureStepExists(trajectory, params.stepId);
-        const access = {
-          providerId: uuidv4(),
-          providerName: params.providerName,
-          timestamp: Date.now(),
-          data: params.data,
-          query: params.query,
-          purpose: params.purpose
-        };
-        step.providerAccesses.push(access);
-        await this.persistTrajectory(trajectoryId, trajectory, "active");
-      });
-    })().catch((err) => {
-      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist provider access");
-    });
-  }
-  logProviderAccessByTrajectoryId(trajectoryId, access) {
-    const stepId = this.getCurrentStepId(trajectoryId);
-    if (!stepId) {
-      logger2.debug({ trajectoryId }, "[trajectory-logger] No active step for provider access by trajectory");
-      return;
-    }
-    this.logProviderAccess(stepId, access);
-  }
-  async startTrajectory(stepIdOrAgentId, options = {}) {
-    if (!this.enabled)
-      return uuidv4();
-    const legacyStepId = typeof options.agentId === "string" && options.agentId.length > 0 ? stepIdOrAgentId : null;
-    const agentId = (typeof options.agentId === "string" && options.agentId.length > 0 ? options.agentId : stepIdOrAgentId) ?? stepIdOrAgentId;
+  startTrajectory(agentId, options = {}) {
     const trajectoryId = uuidv4();
     const now = Date.now();
-    const timestampIso = new Date(now).toISOString();
-    const metadata = {
-      ...options.metadata ?? {}
-    };
-    if (options.roomId)
-      metadata.roomId = options.roomId;
-    if (options.entityId)
-      metadata.entityId = options.entityId;
     const trajectory = {
-      trajectoryId,
-      agentId,
+      trajectoryId: asUUID(trajectoryId),
+      agentId: asUUID(agentId),
       startTime: now,
       endTime: now,
       durationMs: 0,
-      scenarioId: options.scenarioId,
       episodeId: options.episodeId,
+      scenarioId: options.scenarioId,
       batchId: options.batchId,
       groupIndex: options.groupIndex,
       steps: [],
       totalReward: 0,
-      rewardComponents: { environmentReward: 0 },
+      rewardComponents: {
+        environmentReward: 0
+      },
       metrics: {
         episodeLength: 0,
         finalStatus: "completed"
       },
-      metadata: {
-        source: options.source ?? "chat",
-        ...metadata
-      }
+      metadata: options.metadata || {}
     };
-    let persistedStart = false;
-    try {
-      await this.executeRawSql(`
-        INSERT INTO trajectories (
-          id, agent_id, source, status, start_time, scenario_id, episode_id,
-          batch_id, group_index, metadata_json, steps_json, reward_components_json, metrics_json,
-          created_at, updated_at
-        ) VALUES (
-          ${sqlLiteral(trajectoryId)},
-          ${sqlLiteral(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)},
-          ${sqlLiteral([])},
-          ${sqlLiteral(trajectory.rewardComponents)},
-          ${sqlLiteral(trajectory.metrics)},
-          ${sqlLiteral(timestampIso)},
-          ${sqlLiteral(timestampIso)}
-        )
-      `);
-      persistedStart = true;
-    } catch (err) {
-      try {
-        await this.executeRawSql(`
-          INSERT INTO trajectories (
-            id, agent_id, source, status, start_time, steps_json, metadata, created_at, updated_at
-          ) VALUES (
-            ${sqlLiteral(trajectoryId)},
-            ${sqlLiteral(agentId)},
-            ${sqlLiteral(options.source ?? "chat")},
-            'active',
-            ${now},
-            ${sqlLiteral([])},
-            ${sqlLiteral(trajectory.metadata)},
-            ${sqlLiteral(timestampIso)},
-            ${sqlLiteral(timestampIso)}
-          )
-        `);
-        persistedStart = true;
-      } catch (legacyErr) {
-        logger2.warn({ err: legacyErr, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
-      }
-    }
-    if (persistedStart && legacyStepId) {
-      this.stepToTrajectory.set(legacyStepId, trajectoryId);
-      try {
-        await this.setStepIndex(legacyStepId, trajectoryId, -1, false);
-      } catch (indexErr) {
-        logger2.warn({ err: indexErr, trajectoryId, stepId: legacyStepId }, "[trajectory-logger] Failed to persist step index for trajectory start");
-      }
-    }
+    this.activeTrajectories.set(trajectoryId, trajectory);
     return trajectoryId;
   }
   startStep(trajectoryId, envState) {
-    if (!this.enabled)
-      return uuidv4();
     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);
-    this.stepToTrajectory.set(stepId, trajectoryId);
-    this.withTrajectoryWriteLock(trajectoryId, async () => {
-      const trajectory = await this.getTrajectoryById(trajectoryId);
-      if (!trajectory) {
-        logger2.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
-        return;
-      }
-      const step = this.createStep(stepId, trajectory.steps.length, envState);
-      trajectory.steps.push(step);
-      await this.markAllStepsInactive(trajectoryId);
-      await this.setStepIndex(stepId, trajectoryId, step.stepNumber, true);
-      await this.persistTrajectory(trajectoryId, trajectory, "active");
-    }).catch((err) => {
-      logger2.warn({ err, trajectoryId, stepId }, "[trajectory-logger] Failed to persist startStep");
-    });
     return stepId;
   }
-  completeStep(trajectoryId, actionOrStepId, actionOrReward, maybeReward) {
-    if (!this.enabled)
+  logLLMCall(stepId, llmCall) {
+    const trajectory = this.findTrajectoryByStepId(stepId);
+    if (!trajectory) {
+      logger.warn({ stepId }, "Trajectory not found for LLM call");
       return;
-    const explicitStepId = typeof actionOrStepId === "string" ? actionOrStepId : null;
-    const action = typeof actionOrStepId === "string" ? actionOrReward : actionOrStepId;
-    const rewardInfo = typeof actionOrStepId === "string" ? maybeReward : actionOrReward;
-    if (!action)
+    }
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger.warn({ stepId }, "Step not found for LLM call");
       return;
-    this.withTrajectoryWriteLock(trajectoryId, async () => {
-      const trajectory = await this.getTrajectoryById(trajectoryId);
-      if (!trajectory)
-        return;
-      const stepId = explicitStepId ?? this.activeStepIds.get(trajectoryId) ?? await this.getCurrentStepIdFromDb(trajectoryId);
-      if (!stepId)
-        return;
-      const step = await this.ensureStepExists(trajectory, stepId);
-      step.action = {
-        attemptId: uuidv4(),
-        timestamp: Date.now(),
-        ...action
-      };
-      step.done = true;
-      if (rewardInfo?.reward !== undefined) {
-        step.reward = rewardInfo.reward;
-        trajectory.totalReward += rewardInfo.reward;
-      }
-      if (rewardInfo?.components) {
-        trajectory.rewardComponents = {
-          ...trajectory.rewardComponents,
-          ...rewardInfo.components
-        };
-      }
-      await this.setStepIndex(stepId, trajectoryId, step.stepNumber, false);
-      this.activeStepIds.delete(trajectoryId);
-      await this.persistTrajectory(trajectoryId, trajectory, "active");
-    }).catch((err) => {
-      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to complete step");
-    });
+    }
+    const fullLLMCall = {
+      callId: uuidv4(),
+      timestamp: Date.now(),
+      ...llmCall
+    };
+    step.llmCalls.push(fullLLMCall);
   }
-  async endTrajectory(stepIdOrTrajectoryId, status = "completed", finalMetrics) {
-    if (!this.enabled)
-      return;
-    const trajectoryId = await this.resolveTrajectoryId(stepIdOrTrajectoryId);
-    if (!trajectoryId) {
-      logger2.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
+  logProviderAccess(stepId, access) {
+    const trajectory = this.findTrajectoryByStepId(stepId);
+    if (!trajectory) {
+      logger.warn({ stepId }, "Trajectory not found for provider access");
       return;
     }
-    await this.withTrajectoryWriteLock(trajectoryId, async () => {
-      const trajectory = await this.getTrajectoryById(trajectoryId);
-      if (!trajectory) {
-        logger2.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
-        return;
-      }
-      const now = Date.now();
-      trajectory.endTime = now;
-      trajectory.durationMs = now - trajectory.startTime;
-      trajectory.metrics.finalStatus = status;
-      trajectory.metrics.episodeLength = trajectory.steps.length;
-      if (finalMetrics) {
-        trajectory.metrics = {
-          ...trajectory.metrics,
-          ...finalMetrics
-        };
-      }
-      await this.markAllStepsInactive(trajectoryId);
-      this.activeStepIds.delete(trajectoryId);
-      await this.persistTrajectory(trajectoryId, trajectory, status);
-    });
-    for (const [stepId, mappedTrajectoryId] of this.stepToTrajectory.entries()) {
-      if (mappedTrajectoryId === trajectoryId) {
-        this.stepToTrajectory.delete(stepId);
-      }
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger.warn({ stepId }, "Step not found for provider access");
+      return;
     }
+    const fullAccess = {
+      providerId: uuidv4(),
+      timestamp: Date.now(),
+      ...access
+    };
+    step.providerAccesses.push(fullAccess);
   }
-  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}%'
-      )`);
+  logLLMCallByTrajectoryId(trajectoryId, llmCall) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger.warn({ trajectoryId }, "No active step for trajectory");
+      return;
     }
-    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) => {
-      const status = asString(pickCell(row, "status")) ?? "completed";
-      const rawLlmCallCount = asNumber(pickCell(row, "llm_call_count")) ?? 0;
-      const llmCallCount = status === "active" ? rawLlmCallCount : Math.max(1, rawLlmCallCount);
-      return {
-        id: asString(pickCell(row, "id")) ?? "",
-        agentId: asString(pickCell(row, "agent_id")) ?? "",
-        source: asString(pickCell(row, "source")) ?? "chat",
-        status,
-        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,
-        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 };
+    this.logLLMCall(stepId, llmCall);
   }
-  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];
-    const trajectory = this.rowToTrajectory(row);
-    const status = this.normalizeTrajectoryStatus(asString(pickCell(row, "status")));
-    if (status !== "active") {
-      const inserted = this.ensureAtLeastOneLlmCall(trajectory, "backfill");
-      if (inserted) {
-        await this.withTrajectoryWriteLock(trajectoryId, async () => {
-          await this.persistTrajectory(trajectoryId, trajectory, status);
-        });
-      }
+  logProviderAccessByTrajectoryId(trajectoryId, access) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger.warn({ trajectoryId }, "No active step for trajectory");
+      return;
     }
-    return trajectory;
+    this.logProviderAccess(stepId, access);
   }
-  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;
+  getCurrentStepId(trajectoryId) {
+    return this.activeStepIds.get(trajectoryId) || null;
+  }
+  completeStep(trajectoryId, stepId, action, rewardInfo) {
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger.warn({ trajectoryId }, "Trajectory not found for completeStep");
+      return;
     }
-    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;
+    const step = trajectory.steps.find((s) => s.stepId === stepId);
+    if (!step) {
+      logger.warn({ trajectoryId, stepId }, "Step not found for completeStep");
+      return;
     }
-    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;
-  }
-  sanitizeZipFolderName(value) {
-    const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
-    return sanitized || "trajectory";
-  }
-  redactTrajectoryPrompts(trajectory) {
-    return {
-      ...trajectory,
-      steps: trajectory.steps.map((step) => ({
-        ...step,
-        llmCalls: step.llmCalls.map((call) => ({
-          ...call,
-          systemPrompt: "[redacted]",
-          userPrompt: "[redacted]",
-          response: "[redacted]"
-        }))
-      }))
+    step.action = {
+      attemptId: uuidv4(),
+      timestamp: Date.now(),
+      ...action
     };
-  }
-  buildZipSummary(trajectory) {
-    const finalStatus = trajectory.metrics?.finalStatus ?? "completed";
-    const normalizedEndTime = typeof trajectory.endTime === "number" && trajectory.endTime > 0 ? trajectory.endTime : null;
-    const status = finalStatus === "timeout" || finalStatus === "terminated" || finalStatus === "error" ? "error" : finalStatus === "completed" ? "completed" : normalizedEndTime ? "completed" : "active";
-    let llmCallCount = 0;
-    let providerAccessCount = 0;
-    let totalPromptTokens = 0;
-    let totalCompletionTokens = 0;
-    for (const step of trajectory.steps) {
-      providerAccessCount += step.providerAccesses.length;
-      llmCallCount += step.llmCalls.length;
-      for (const call of step.llmCalls) {
-        totalPromptTokens += call.promptTokens ?? 0;
-        totalCompletionTokens += call.completionTokens ?? 0;
-      }
+    if (rewardInfo?.reward !== undefined) {
+      step.reward = rewardInfo.reward;
+      trajectory.totalReward += rewardInfo.reward;
+    }
+    if (rewardInfo?.components) {
+      trajectory.rewardComponents = {
+        ...trajectory.rewardComponents,
+        ...rewardInfo.components
+      };
     }
-    const metadata = trajectory.metadata ?? {};
-    const asNullableString = (value) => typeof value === "string" ? value : null;
-    const source = typeof metadata.source === "string" ? metadata.source : "chat";
-    const normalizedDurationMs = status === "active" ? null : typeof trajectory.durationMs === "number" ? trajectory.durationMs : null;
-    const updatedAtMs = normalizedEndTime ?? (trajectory.startTime || Date.now());
-    return {
-      id: trajectory.trajectoryId,
-      agentId: trajectory.agentId,
-      roomId: asNullableString(metadata.roomId),
-      entityId: asNullableString(metadata.entityId),
-      conversationId: asNullableString(metadata.conversationId),
-      source,
-      status,
-      startTime: trajectory.startTime,
-      endTime: normalizedEndTime,
-      durationMs: normalizedDurationMs,
-      llmCallCount,
-      providerAccessCount,
-      totalPromptTokens,
-      totalCompletionTokens,
-      metadata,
-      createdAt: new Date(trajectory.startTime).toISOString(),
-      updatedAt: new Date(updatedAtMs).toISOString()
-    };
+    this.activeStepIds.delete(trajectoryId);
   }
-  async exportTrajectoriesZip(options = {}) {
-    let targetIds = Array.isArray(options.trajectoryIds) ? options.trajectoryIds.filter((id) => typeof id === "string" && id.trim().length > 0) : [];
-    if (targetIds.length === 0) {
-      const list = await this.listTrajectories({
-        limit: 500,
-        startDate: options.startDate,
-        endDate: options.endDate,
-        scenarioId: options.scenarioId,
-        batchId: options.batchId
-      });
-      targetIds = list.trajectories.map((trajectory) => trajectory.id);
-    }
-    const entries = [];
-    const manifestRows = [];
-    for (const trajectoryId of targetIds) {
-      const detail = await this.getTrajectoryDetail(trajectoryId);
-      if (!detail)
-        continue;
-      const exportTrajectory = options.includePrompts === false ? this.redactTrajectoryPrompts(detail) : detail;
-      const summary = this.buildZipSummary(exportTrajectory);
-      const folderName = this.sanitizeZipFolderName(trajectoryId);
-      entries.push({
-        name: `${folderName}/trajectory.json`,
-        data: JSON.stringify(exportTrajectory, null, 2)
-      });
-      entries.push({
-        name: `${folderName}/summary.json`,
-        data: JSON.stringify(summary, null, 2)
-      });
-      manifestRows.push({
-        trajectoryId,
-        folder: folderName,
-        createdAt: summary.createdAt
-      });
+  completeCurrentStep(trajectoryId, action, rewardInfo) {
+    const stepId = this.activeStepIds.get(trajectoryId);
+    if (!stepId) {
+      logger.warn({ trajectoryId }, "No active step for trajectory");
+      return;
     }
-    entries.unshift({
-      name: "manifest.json",
-      data: JSON.stringify({
-        exportedAt: new Date().toISOString(),
-        trajectories: manifestRows
-      }, null, 2)
-    });
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    return {
-      filename: `trajectories-${timestamp}.zip`,
-      entries
-    };
+    this.completeStep(trajectoryId, stepId, action, rewardInfo);
   }
-  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)}`);
+  async endTrajectory(trajectoryId, status, finalMetrics) {
+    const trajectory = this.activeTrajectories.get(trajectoryId);
+    if (!trajectory) {
+      logger.warn({ trajectoryId }, "Trajectory not found for endTrajectory");
+      return;
     }
-    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"
+    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
       };
     }
-    let exportData = trajectories;
-    if (!options.includePrompts) {
-      exportData = trajectories.map((trajectory) => this.redactTrajectoryPrompts(trajectory));
-    }
-    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", "steps"), []),
-      totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
-      rewardComponents: parseJson(pickCell(row, "reward_components_json", "reward_components"), { environmentReward: 0 }),
-      metrics: parseJson(pickCell(row, "metrics_json", "metrics"), {
-        episodeLength: 0,
-        finalStatus: "completed"
-      }),
-      metadata: parseJson(pickCell(row, "metadata_json", "metadata"), {})
-    };
+    this.activeStepIds.delete(trajectoryId);
   }
   getActiveTrajectory(trajectoryId) {
-    return null;
-  }
-  getCurrentStepId(trajectoryId) {
-    return this.activeStepIds.get(trajectoryId) || null;
-  }
-  getProviderAccessLogs() {
-    return [];
+    return this.activeTrajectories.get(trajectoryId) || null;
   }
-  getLlmCallLogs() {
-    return [];
+  findTrajectoryByStepId(stepId) {
+    for (const trajectory of this.activeTrajectories.values()) {
+      if (trajectory.steps.some((s) => s.stepId === stepId)) {
+        return trajectory;
+      }
+    }
+    return null;
   }
 }
+
 // action-interceptor.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger2 } from "@elizaos/core";
 var trajectoryContexts = new WeakMap;
 function setTrajectoryContext(runtime, trajectoryId, trajectoryLogger) {
   trajectoryContexts.set(runtime, { trajectoryId, logger: trajectoryLogger });
@@ -3082,7 +211,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger3.warn({ action: action.name, trajectoryId }, "No active step for action execution");
+        logger2.warn({ action: action.name, trajectoryId }, "No active step for action execution");
         const result = await originalHandler(runtime, message, state, options, callback);
         return result ?? undefined;
       }
@@ -3102,7 +231,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       };
       const errorHandler = (err) => {
         const error = err instanceof Error ? err.message : typeof err === "string" ? err : err.message || String(err);
-        logger3.error({ action: action.name, trajectoryId, error }, "Action execution failed");
+        logger2.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,
@@ -3145,7 +274,7 @@ function wrapPluginActions(plugin, trajectoryLogger) {
 function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger3.warn({ trajectoryId }, "No active step for LLM call from action");
+    logger2.warn({ trajectoryId }, "No active step for LLM call from action");
     return;
   }
   trajectoryLogger.logLLMCall(stepId, {
@@ -3166,7 +295,7 @@ function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
 function logProviderFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger3.warn({ trajectoryId }, "No active step for provider access from action");
+    logger2.warn({ trajectoryId }, "No active step for provider access from action");
     return;
   }
   trajectoryLogger.logProviderAccess(stepId, {
@@ -3188,7 +317,7 @@ function wrapProviderWithLogging(provider, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger3.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
+        logger2.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: "" };
@@ -3390,14 +519,14 @@ function toARTJSONL(trajectory) {
   return JSON.stringify(toARTTrajectory(trajectory));
 }
 function validateARTCompatibility(trajectory) {
-  const errors2 = [];
+  const errors = [];
   const warnings = [];
   if (trajectory.steps.length === 0) {
-    errors2.push("Trajectory has no steps");
+    errors.push("Trajectory has no steps");
   }
   for (const [idx, step] of trajectory.steps.entries()) {
     if (step.llmCalls.length === 0) {
-      errors2.push(`Step ${idx} has no LLM calls - can't extract messages`);
+      errors.push(`Step ${idx} has no LLM calls - can't extract messages`);
     }
     for (const llmCall of step.llmCalls) {
       if (!llmCall.userPrompt || llmCall.userPrompt.length < 10) {
@@ -3409,15 +538,15 @@ function validateARTCompatibility(trajectory) {
     }
   }
   if (trajectory.totalReward === undefined || Number.isNaN(trajectory.totalReward)) {
-    errors2.push("Trajectory has no valid reward");
+    errors.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: errors2.length === 0,
-    errors: errors2,
+    valid: errors.length === 0,
+    errors,
     warnings
   };
 }
@@ -3513,9 +642,9 @@ async function buildGameStateFromDB(_trajectoryId) {
 }
 async function recomputeTrajectoryRewards(_trajectoryIds) {}
 // integration.ts
-import { logger as logger4 } from "@elizaos/core";
-async function startAutonomousTick(trajectoryLogger, context) {
-  const trajectoryId = await trajectoryLogger.startTrajectory(context.agentId, {
+import { logger as logger3 } from "@elizaos/core";
+function startAutonomousTick(trajectoryLogger, context) {
+  const trajectoryId = trajectoryLogger.startTrajectory(context.agentId, {
     scenarioId: context.scenarioId,
     episodeId: context.episodeId,
     batchId: context.batchId,
@@ -3529,17 +658,17 @@ async function startAutonomousTick(trajectoryLogger, context) {
     openPositions: 0
   };
   trajectoryLogger.startStep(trajectoryId, envState);
-  logger4.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
+  logger3.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);
-  logger4.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
+  logger3.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
 }
 async function loggedLLMCall(trajectoryLogger, trajectoryId, options, llmCallFn) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger4.warn({ trajectoryId }, "No active step for LLM call");
+    logger3.warn({ trajectoryId }, "No active step for LLM call");
     const result2 = await llmCallFn();
     return result2.text;
   }
@@ -3644,13 +773,13 @@ class RewardService {
     return (score + 1) / 2;
   }
   normalizeScoresForGroup(scores) {
-    const min2 = Math.min(...scores);
-    const max2 = Math.max(...scores);
-    const range = max2 - min2;
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const range = max - min;
     if (range === 0) {
       return scores.map(() => 0.5);
     }
-    return scores.map((s) => (s - min2) / range);
+    return scores.map((s) => (s - min) / range);
   }
 }
 function createRewardService(options = {}) {
@@ -3680,18 +809,16 @@ var trajectoryLoggerPlugin = {
         if (!message || !runtime)
           return;
         if (!message.metadata) {
-          message.metadata = {
-            type: "message"
-          };
+          message.metadata = { type: "message" };
         }
         const meta = message.metadata;
-        const logger5 = runtime.getService("trajectory_logger");
-        if (!logger5)
+        const logger4 = runtime.getService("trajectory_logger");
+        if (!logger4)
           return;
         let trajectoryStepId = crypto.randomUUID();
         meta.trajectoryStepId = trajectoryStepId;
         try {
-          const trajectoryId = await logger5.startTrajectory(runtime.agentId, {
+          const trajectoryId = await logger4.startTrajectory(runtime.agentId, {
             source: source ?? meta.source ?? "chat",
             metadata: {
               roomId: message.roomId,
@@ -3703,7 +830,7 @@ var trajectoryLoggerPlugin = {
           });
           const normalizedTrajectoryId = typeof trajectoryId === "string" && trajectoryId.trim().length > 0 ? trajectoryId : null;
           if (normalizedTrajectoryId) {
-            const runtimeStepId = logger5.startStep(normalizedTrajectoryId, {
+            const runtimeStepId = logger4.startStep(normalizedTrajectoryId, {
               timestamp: Date.now(),
               agentBalance: 0,
               agentPoints: 0,
@@ -3714,17 +841,13 @@ var trajectoryLoggerPlugin = {
             trajectoryStepId = normalizedStepId;
             meta.trajectoryStepId = trajectoryStepId;
             pendingTrajectoryEndTargetByStepId.set(trajectoryStepId, normalizedTrajectoryId);
-          } else {}
+          }
           if (message.id) {
             const replyId = createUniqueUuid(runtime, message.id);
             pendingTrajectoryStepByReplyId.set(replyId, trajectoryStepId);
           }
         } catch (err) {
-          runtime.logger?.warn({
-            err,
-            src: "plugin-trajectory-logger",
-            roomId: message.roomId
-          }, "Failed to start trajectory logging");
+          runtime.logger?.warn({ err, src: "plugin-trajectory-logger", roomId: message.roomId }, "Failed to start trajectory logging");
         }
       }
     ],
@@ -3741,18 +864,14 @@ var trajectoryLoggerPlugin = {
         }
         if (!trajectoryStepId)
           return;
-        const logger5 = runtime.getService("trajectory_logger");
-        if (!logger5)
+        const logger4 = runtime.getService("trajectory_logger");
+        if (!logger4)
           return;
         try {
           const endTarget = pendingTrajectoryEndTargetByStepId.get(trajectoryStepId) ?? trajectoryStepId;
-          await logger5.endTrajectory(endTarget, "completed");
+          await logger4.endTrajectory(endTarget, "completed");
         } catch (err) {
-          runtime.logger?.warn({
-            err,
-            src: "plugin-trajectory-logger",
-            trajectoryStepId
-          }, "Failed to end trajectory logging");
+          runtime.logger?.warn({ err, src: "plugin-trajectory-logger", trajectoryStepId }, "Failed to end trajectory logging");
         }
         if (inReplyTo) {
           pendingTrajectoryStepByReplyId.delete(inReplyTo);
@@ -3803,4 +922,4 @@ export {
   RewardService
 };
 
-//# debugId=FBBDF38FEFEB663664756E2164756E21
+//# debugId=F0E0006C38150F8464756E2164756E21