@elizaos/plugin-trajectory-logger 2.0.0-alpha.12 → 2.0.0-alpha.15

package/dist/node/index.node.js

@@ -1,5 +1,1801 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+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 {
@@ -8,8 +1804,25 @@ import {
 import crypto from "node:crypto";
 
 // TrajectoryLoggerService.ts
-import { logger, Service } from "@elizaos/core";
+import {
+  logger as logger2,
+  Service,
+  getTrajectoryContext,
+  runWithTrajectoryContext,
+  setTrajectoryContextManager,
+  ModelType
+} from "@elizaos/core";
 import { v4 as uuidv4 } from "uuid";
+import { AsyncLocalStorage } from "node:async_hooks";
+var trajectoryStorage = new AsyncLocalStorage;
+setTrajectoryContextManager({
+  run(context, fn) {
+    return trajectoryStorage.run(context, fn);
+  },
+  active() {
+    return trajectoryStorage.getStore();
+  }
+});
 function asNumber(value) {
   if (typeof value === "number" && Number.isFinite(value))
     return value;
@@ -67,6 +1880,96 @@ class TrajectoryLoggerService extends Service {
   capabilityDescription = "Captures and persists LLM calls, provider accesses, and full trajectories for debugging, analysis, and RL training";
   enabled = true;
   initialized = false;
+  observationBuffer = [];
+  observationFlushTimer = null;
+  observationFlushInProgress = false;
+  OBSERVATION_BUFFER_THRESHOLD = 5;
+  OBSERVATION_FLUSH_INTERVAL_MS = 10 * 60 * 1000;
+  pushChatExchange(exchange) {
+    this.observationBuffer.push(exchange);
+    if (this.observationBuffer.length >= this.OBSERVATION_BUFFER_THRESHOLD) {
+      this.flushObservationBuffer().catch(() => {});
+      return;
+    }
+    if (this.observationFlushTimer)
+      clearTimeout(this.observationFlushTimer);
+    this.observationFlushTimer = setTimeout(() => {
+      this.flushObservationBuffer().catch(() => {});
+    }, this.OBSERVATION_FLUSH_INTERVAL_MS);
+  }
+  async flushObservationBuffer() {
+    if (this.observationFlushInProgress)
+      return [];
+    this.observationFlushInProgress = true;
+    if (this.observationBuffer.length === 0) {
+      this.observationFlushInProgress = false;
+      return [];
+    }
+    const exchanges = this.observationBuffer.splice(0, this.observationBuffer.length);
+    if (this.observationFlushTimer) {
+      clearTimeout(this.observationFlushTimer);
+      this.observationFlushTimer = null;
+    }
+    const OBSERVATION_EXTRACTION_PROMPT = `You are analyzing recent conversation exchanges between a user and an AI assistant.
+Extract any durable observations about the user that would be useful across future sessions.
+
+Categories to look for:
+- Preferences (tools, languages, workflows, communication style)
+- Facts (role, location, projects they work on, tech stack)
+- Standing instructions (things they always/never want)
+- Patterns (recurring topics, how they like to work)
+
+Return ONLY a JSON array of short observation strings (max 150 chars each).
+If nothing meaningful is found, return an empty array [].
+Do NOT include observations about the conversation itself, only about the user.
+
+Recent exchanges:
+`;
+    const exchangeText = exchanges.map((e, i) => `Exchange ${i + 1}:
+User: ${e.userPrompt.slice(0, 500)}
+Assistant: ${e.response.slice(0, 500)}`).join(`
+
+`);
+    const prompt = OBSERVATION_EXTRACTION_PROMPT + exchangeText;
+    const runtimeAny = this.runtime;
+    try {
+      runtimeAny.__orchestratorTrajectoryCtx = {
+        source: "orchestrator",
+        decisionType: "observation-extraction"
+      };
+      const result = await this.runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt,
+        maxTokens: 512,
+        temperature: 0
+      });
+      const jsonMatch = result.match(/\[[\s\S]*\]/);
+      if (!jsonMatch)
+        return [];
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed))
+        return [];
+      const observations = parsed.filter((s) => typeof s === "string" && s.length > 0).map((s) => s.slice(0, 150));
+      if (observations.length === 0)
+        return [];
+      const lastExchange = exchanges[exchanges.length - 1];
+      await this.withTrajectoryWriteLock(lastExchange.trajectoryId, async () => {
+        const trajectory = await this.getTrajectoryById(lastExchange.trajectoryId);
+        if (trajectory) {
+          const meta = trajectory.metadata ?? {};
+          const existing = Array.isArray(meta.observations) ? meta.observations : [];
+          meta.observations = [...existing, ...observations].slice(-30);
+          trajectory.metadata = meta;
+          await this.persistTrajectory(lastExchange.trajectoryId, trajectory, trajectory.metrics?.finalStatus || "completed");
+        }
+      });
+      return observations;
+    } catch {
+      return [];
+    } finally {
+      delete runtimeAny.__orchestratorTrajectoryCtx;
+      this.observationFlushInProgress = false;
+    }
+  }
   activeStepIds = new Map;
   stepToTrajectory = new Map;
   writeQueues = new Map;
@@ -85,7 +1988,7 @@ class TrajectoryLoggerService extends Service {
     return this.enabled;
   }
   async getSqlHelper() {
-    const drizzle = await import("drizzle-orm");
+    const drizzle = await Promise.resolve().then(() => (init_drizzle_orm(), exports_drizzle_orm));
     return drizzle.sql;
   }
   async executeRawSql(sqlText) {
@@ -106,13 +2009,36 @@ class TrajectoryLoggerService extends Service {
       return;
     const runtime = this.runtime;
     if (!runtime?.adapter) {
-      logger.warn("[trajectory-logger] No runtime adapter available, skipping initialization");
+      logger2.warn("[trajectory-logger] No runtime adapter available, skipping initialization");
       return;
     }
     await this.ensureTablesExist();
     await this.backfillTrajectoriesMissingLlmCalls();
+    const originalUseModel = runtime.useModel;
+    if (typeof originalUseModel === "function") {
+      const patchedUseModel = async function(...args) {
+        const context = getTrajectoryContext();
+        if (context?.trajectoryStepId) {
+          return originalUseModel.call(this, ...args);
+        }
+        const trajLogger = runtime.getService(TrajectoryLoggerService.serviceType);
+        if (!trajLogger || !trajLogger.isEnabled()) {
+          return originalUseModel.call(this, ...args);
+        }
+        const stepId = await trajLogger.startTrajectory(runtime.agentId, {
+          source: "chat-orphan",
+          metadata: { autoPatch: true }
+        });
+        try {
+          return await runWithTrajectoryContext({ trajectoryStepId: stepId }, () => originalUseModel.call(this, ...args));
+        } finally {
+          await trajLogger.endTrajectory(stepId, "completed");
+        }
+      };
+      runtime.useModel = patchedUseModel;
+    }
     this.initialized = true;
-    logger.info("[trajectory-logger] Trajectory logger service initialized");
+    logger2.info("[trajectory-logger] Trajectory logger service initialized");
   }
   async getTableColumnNames(tableName) {
     const names = new Set;
@@ -124,9 +2050,9 @@ class TrajectoryLoggerService extends Service {
           AND table_schema NOT IN ('pg_catalog', 'information_schema')
       `);
       for (const row of result.rows) {
-        const name = asString(pickCell(row, "column_name"));
-        if (name)
-          names.add(name);
+        const name2 = asString(pickCell(row, "column_name"));
+        if (name2)
+          names.add(name2);
       }
       if (names.size > 0)
         return names;
@@ -137,9 +2063,9 @@ class TrajectoryLoggerService extends Service {
     try {
       const pragma = await this.executeRawSql(`PRAGMA table_info(${safeTableName})`);
       for (const row of pragma.rows) {
-        const name = asString(pickCell(row, "name"));
-        if (name)
-          names.add(name);
+        const name2 = asString(pickCell(row, "name"));
+        if (name2)
+          names.add(name2);
       }
     } catch {}
     return names;
@@ -179,7 +2105,7 @@ class TrajectoryLoggerService extends Service {
           if (combinedMessage.includes("already exists") || combinedMessage.includes("duplicate column") || combinedMessage.includes("duplicate_column")) {
             continue;
           }
-          logger.warn(`[trajectory-logger] Failed to add trajectories.${columnName} (non-fatal): ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`);
+          logger2.warn(`[trajectory-logger] Failed to add trajectories.${columnName} (non-fatal): ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`);
         }
       }
     }
@@ -240,7 +2166,7 @@ class TrajectoryLoggerService extends Service {
       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) {
-      logger.warn(`[trajectory-logger] Failed to create indexes (non-fatal): ${e instanceof Error ? e.message : String(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 (
@@ -296,13 +2222,13 @@ class TrajectoryLoggerService extends Service {
         });
       }
       if (fixed > 0) {
-        logger.info(`[trajectory-logger] Backfilled ${fixed} completed trajectories with synthetic LLM calls`);
+        logger2.info(`[trajectory-logger] Backfilled ${fixed} completed trajectories with synthetic LLM calls`);
       }
       if (rows.rows.length >= maxRows) {
-        logger.warn(`[trajectory-logger] Backfill hit safety cap (${maxRows}); remaining older trajectories will be fixed lazily when touched`);
+        logger2.warn(`[trajectory-logger] Backfill hit safety cap (${maxRows}); remaining older trajectories will be fixed lazily when touched`);
       }
     } catch (err) {
-      logger.warn(`[trajectory-logger] Failed to backfill trajectories missing LLM calls (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+      logger2.warn(`[trajectory-logger] Failed to backfill trajectories missing LLM calls (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   normalizePurpose(value) {
@@ -540,7 +2466,7 @@ class TrajectoryLoggerService extends Service {
           updated_at = ${sqlLiteral(updatedAtIso)}
         WHERE id = ${sqlLiteral(trajectoryId)}
       `).catch((legacyErr) => {
-        logger.warn({ err: legacyErr, trajectoryId }, `[trajectory-logger] Failed to persist trajectory update after compatibility fallback: ${modernErr instanceof Error ? modernErr.message : String(modernErr)}`);
+        logger2.warn({ err: legacyErr, trajectoryId }, `[trajectory-logger] Failed to persist trajectory update after compatibility fallback: ${modernErr instanceof Error ? modernErr.message : String(modernErr)}`);
         throw legacyErr;
       });
     }
@@ -564,16 +2490,34 @@ class TrajectoryLoggerService extends Service {
   logLlmCall(params) {
     if (!this.enabled)
       return;
+    if (shouldSuppressNoInputEmbeddingCall(params))
+      return;
+    const orchestratorCtx = readOrchestratorTrajectoryContext(this.runtime);
     (async () => {
       const trajectoryId = await this.resolveTrajectoryId(params.stepId);
       if (!trajectoryId) {
-        logger.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for LLM call");
+        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;
+        if (orchestratorCtx) {
+          trajectory.source = "orchestrator";
+          if (!trajectory.metadata)
+            trajectory.metadata = {};
+          trajectory.metadata.orchestrator = { ...orchestratorCtx };
+        }
+        const fullResponse = String(params.response || "");
+        const purposeText = orchestratorCtx?.decisionType ?? String(params.purpose || "action");
+        const insights = extractInsightsFromResponse(fullResponse, purposeText);
+        if (insights.length > 0) {
+          if (!trajectory.metadata)
+            trajectory.metadata = {};
+          const existing = Array.isArray(trajectory.metadata.insights) ? trajectory.metadata.insights : [];
+          trajectory.metadata.insights = [...existing, ...insights].slice(-20);
+        }
         const step = await this.ensureStepExists(trajectory, params.stepId);
         const llmCall = {
           callId: uuidv4(),
@@ -586,17 +2530,27 @@ class TrajectoryLoggerService extends Service {
           reasoning: params.reasoning,
           temperature: params.temperature,
           maxTokens: params.maxTokens,
-          purpose: this.normalizePurpose(params.purpose),
-          actionType: params.actionType,
+          purpose: this.normalizePurpose(purposeText),
+          actionType: orchestratorCtx ? "orchestrator.useModel" : params.actionType || "runtime.useModel",
           promptTokens: params.promptTokens,
           completionTokens: params.completionTokens,
           latencyMs: params.latencyMs
         };
         step.llmCalls.push(llmCall);
+        trajectory.startTime = Math.min(trajectory.startTime, llmCall.timestamp);
+        trajectory.endTime = Math.max(trajectory.endTime ?? llmCall.timestamp, llmCall.timestamp);
         await this.persistTrajectory(trajectoryId, trajectory, "active");
+        if (!orchestratorCtx && trajectory.source === "chat" && shouldRunObservationExtraction(this.runtime)) {
+          this.pushChatExchange({
+            userPrompt: String(params.userPrompt ?? ""),
+            response: fullResponse,
+            trajectoryId,
+            timestamp: llmCall.timestamp
+          });
+        }
       });
     })().catch((err) => {
-      logger.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist LLM call");
+      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist LLM call");
     });
   }
   logLLMCall(stepId, details) {
@@ -630,7 +2584,7 @@ class TrajectoryLoggerService extends Service {
     (async () => {
       const trajectoryId = await this.resolveTrajectoryId(params.stepId);
       if (!trajectoryId) {
-        logger.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for provider access");
+        logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for provider access");
         return;
       }
       await this.withTrajectoryWriteLock(trajectoryId, async () => {
@@ -650,13 +2604,13 @@ class TrajectoryLoggerService extends Service {
         await this.persistTrajectory(trajectoryId, trajectory, "active");
       });
     })().catch((err) => {
-      logger.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist provider access");
+      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist provider access");
     });
   }
   logProviderAccessByTrajectoryId(trajectoryId, access) {
     const stepId = this.getCurrentStepId(trajectoryId);
     if (!stepId) {
-      logger.debug({ trajectoryId }, "[trajectory-logger] No active step for provider access by trajectory");
+      logger2.debug({ trajectoryId }, "[trajectory-logger] No active step for provider access by trajectory");
       return;
     }
     this.logProviderAccess(stepId, access);
@@ -743,7 +2697,7 @@ class TrajectoryLoggerService extends Service {
         `);
         persistedStart = true;
       } catch (legacyErr) {
-        logger.warn({ err: legacyErr, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
+        logger2.warn({ err: legacyErr, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
       }
     }
     if (persistedStart && legacyStepId) {
@@ -751,7 +2705,7 @@ class TrajectoryLoggerService extends Service {
       try {
         await this.setStepIndex(legacyStepId, trajectoryId, -1, false);
       } catch (indexErr) {
-        logger.warn({ err: indexErr, trajectoryId, stepId: legacyStepId }, "[trajectory-logger] Failed to persist step index for trajectory start");
+        logger2.warn({ err: indexErr, trajectoryId, stepId: legacyStepId }, "[trajectory-logger] Failed to persist step index for trajectory start");
       }
     }
     return trajectoryId;
@@ -765,7 +2719,7 @@ class TrajectoryLoggerService extends Service {
     this.withTrajectoryWriteLock(trajectoryId, async () => {
       const trajectory = await this.getTrajectoryById(trajectoryId);
       if (!trajectory) {
-        logger.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
+        logger2.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
         return;
       }
       const step = this.createStep(stepId, trajectory.steps.length, envState);
@@ -774,7 +2728,7 @@ class TrajectoryLoggerService extends Service {
       await this.setStepIndex(stepId, trajectoryId, step.stepNumber, true);
       await this.persistTrajectory(trajectoryId, trajectory, "active");
     }).catch((err) => {
-      logger.warn({ err, trajectoryId, stepId }, "[trajectory-logger] Failed to persist startStep");
+      logger2.warn({ err, trajectoryId, stepId }, "[trajectory-logger] Failed to persist startStep");
     });
     return stepId;
   }
@@ -814,7 +2768,7 @@ class TrajectoryLoggerService extends Service {
       this.activeStepIds.delete(trajectoryId);
       await this.persistTrajectory(trajectoryId, trajectory, "active");
     }).catch((err) => {
-      logger.warn({ err, trajectoryId }, "[trajectory-logger] Failed to complete step");
+      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to complete step");
     });
   }
   async endTrajectory(stepIdOrTrajectoryId, status = "completed", finalMetrics) {
@@ -822,13 +2776,13 @@ class TrajectoryLoggerService extends Service {
       return;
     const trajectoryId = await this.resolveTrajectoryId(stepIdOrTrajectoryId);
     if (!trajectoryId) {
-      logger.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
+      logger2.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
       return;
     }
     await this.withTrajectoryWriteLock(trajectoryId, async () => {
       const trajectory = await this.getTrajectoryById(trajectoryId);
       if (!trajectory) {
-        logger.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
+        logger2.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
         return;
       }
       const now = Date.now();
@@ -1041,9 +2995,9 @@ class TrajectoryLoggerService extends Service {
     if (!runtime?.adapter)
       return 0;
     const countResult = await this.executeRawSql(`SELECT count(*)::int AS cnt FROM trajectories`);
-    const count = asNumber(pickCell(countResult.rows[0] ?? {}, "cnt")) ?? 0;
+    const count2 = asNumber(pickCell(countResult.rows[0] ?? {}, "cnt")) ?? 0;
     await this.executeRawSql(`DELETE FROM trajectories`);
-    return count;
+    return count2;
   }
   sanitizeZipFolderName(value) {
     const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
@@ -1192,7 +3146,7 @@ class TrajectoryLoggerService extends Service {
           t.endTime,
           t.durationMs,
           t.steps.length,
-          t.steps.reduce((sum, s) => sum + s.llmCalls.length, 0),
+          t.steps.reduce((sum2, s) => sum2 + s.llmCalls.length, 0),
           t.totalReward,
           t.scenarioId ?? ""
         ].join(","));
@@ -1261,13 +3215,92 @@ class TrajectoryLoggerService extends Service {
     return [];
   }
 }
+function extractInsightsFromResponse(response, purpose) {
+  const insights = [];
+  const decisionPattern = /DECISION:\s*(.+?)(?:\n|$)/gi;
+  let match;
+  match = decisionPattern.exec(response);
+  while (match !== null) {
+    insights.push(match[1].trim());
+    match = decisionPattern.exec(response);
+  }
+  const keyDecisionPattern = /"keyDecision"\s*:\s*"([^"]+)"/g;
+  match = keyDecisionPattern.exec(response);
+  while (match !== null) {
+    insights.push(match[1].trim());
+    match = keyDecisionPattern.exec(response);
+  }
+  if ((purpose === "turn-complete" || purpose === "coordination") && insights.length === 0) {
+    const reasoningMatch = response.match(/"reasoning"\s*:\s*"([^"]{20,200})"/);
+    if (reasoningMatch)
+      insights.push(reasoningMatch[1].trim());
+  }
+  return insights;
+}
+function readOrchestratorTrajectoryContext(runtime) {
+  if (!runtime || typeof runtime !== "object")
+    return;
+  const ctx = runtime.__orchestratorTrajectoryCtx;
+  if (!ctx || typeof ctx !== "object")
+    return;
+  const candidate = ctx;
+  if (candidate.source !== "orchestrator" || typeof candidate.decisionType !== "string")
+    return;
+  return candidate;
+}
+function isNumericVectorString(value) {
+  const trimmed = value.trim();
+  if (trimmed === "[array]")
+    return true;
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]"))
+    return false;
+  const inner = trimmed.slice(1, -1).trim();
+  if (!inner)
+    return false;
+  const parts = inner.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (parts.length < 8)
+    return false;
+  const sampleSize = Math.min(parts.length, 16);
+  for (let i = 0;i < sampleSize; i += 1) {
+    const numeric = Number(parts[i]);
+    if (!Number.isFinite(numeric))
+      return false;
+  }
+  return true;
+}
+function shouldSuppressNoInputEmbeddingCall(params) {
+  const model = String(params.model || "").toLowerCase();
+  const actionType = String(params.actionType || "").toLowerCase();
+  const purpose = String(params.purpose || "").toLowerCase();
+  const isEmbedding = model.includes("embed") || actionType.includes("embed") || purpose.includes("embed");
+  if (!isEmbedding)
+    return false;
+  const userPrompt = String(params.userPrompt ?? params.input ?? "").trim();
+  if (userPrompt.length > 0)
+    return false;
+  const response = String(params.response || "");
+  if (!response.trim())
+    return true;
+  return isNumericVectorString(response);
+}
+function shouldRunObservationExtraction(runtime) {
+  if (typeof runtime.getSetting === "function") {
+    const setting = runtime.getSetting("TRAJECTORY_OBSERVATION_EXTRACTION");
+    if (setting === "true")
+      return true;
+    if (setting === "false")
+      return false;
+  }
+  const hasReflection = Array.isArray(runtime.evaluators) && runtime.evaluators.some((e) => e.name === "REFLECTION" || e.name === "RELATIONSHIP_EXTRACTION");
+  return !hasReflection;
+}
 // action-interceptor.ts
-import { logger as logger2 } from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
 var trajectoryContexts = new WeakMap;
 function setTrajectoryContext(runtime, trajectoryId, trajectoryLogger) {
   trajectoryContexts.set(runtime, { trajectoryId, logger: trajectoryLogger });
 }
-function getTrajectoryContext(runtime) {
+function getTrajectoryContext2(runtime) {
   return trajectoryContexts.get(runtime) || null;
 }
 function clearTrajectoryContext(runtime) {
@@ -1278,7 +3311,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
   return {
     ...action,
     handler: async (runtime, message, state, options, callback) => {
-      const context = getTrajectoryContext(runtime);
+      const context = getTrajectoryContext2(runtime);
       if (!context) {
         const result = await originalHandler(runtime, message, state, options, callback);
         return result ?? undefined;
@@ -1286,7 +3319,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger2.warn({ action: action.name, trajectoryId }, "No active step for action execution");
+        logger3.warn({ action: action.name, trajectoryId }, "No active step for action execution");
         const result = await originalHandler(runtime, message, state, options, callback);
         return result ?? undefined;
       }
@@ -1306,7 +3339,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       };
       const errorHandler = (err) => {
         const error = err instanceof Error ? err.message : typeof err === "string" ? err : err.message || String(err);
-        logger2.error({ action: action.name, trajectoryId, error }, "Action execution failed");
+        logger3.error({ action: action.name, trajectoryId, error }, "Action execution failed");
         const stateSnapshot = state ? JSON.parse(JSON.stringify(state)) : null;
         loggerService.completeStep(trajectoryId, stepId, {
           actionType: action.name,
@@ -1349,7 +3382,7 @@ function wrapPluginActions(plugin, trajectoryLogger) {
 function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger2.warn({ trajectoryId }, "No active step for LLM call from action");
+    logger3.warn({ trajectoryId }, "No active step for LLM call from action");
     return;
   }
   trajectoryLogger.logLLMCall(stepId, {
@@ -1370,7 +3403,7 @@ function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
 function logProviderFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger2.warn({ trajectoryId }, "No active step for provider access from action");
+    logger3.warn({ trajectoryId }, "No active step for provider access from action");
     return;
   }
   trajectoryLogger.logProviderAccess(stepId, {
@@ -1385,14 +3418,14 @@ function wrapProviderWithLogging(provider, _trajectoryLogger) {
   return {
     ...provider,
     get: async (runtime, message, state) => {
-      const context = getTrajectoryContext(runtime);
+      const context = getTrajectoryContext2(runtime);
       if (!context) {
         return originalGet?.(runtime, message, state) || { text: "" };
       }
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger2.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
+        logger3.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
         return originalGet?.(runtime, message, state) || { text: "" };
       }
       const result = await originalGet?.(runtime, message, state) || { text: "" };
@@ -1594,14 +3627,14 @@ function toARTJSONL(trajectory) {
   return JSON.stringify(toARTTrajectory(trajectory));
 }
 function validateARTCompatibility(trajectory) {
-  const errors = [];
+  const errors2 = [];
   const warnings = [];
   if (trajectory.steps.length === 0) {
-    errors.push("Trajectory has no steps");
+    errors2.push("Trajectory has no steps");
   }
   for (const [idx, step] of trajectory.steps.entries()) {
     if (step.llmCalls.length === 0) {
-      errors.push(`Step ${idx} has no LLM calls - can't extract messages`);
+      errors2.push(`Step ${idx} has no LLM calls - can't extract messages`);
     }
     for (const llmCall of step.llmCalls) {
       if (!llmCall.userPrompt || llmCall.userPrompt.length < 10) {
@@ -1613,15 +3646,15 @@ function validateARTCompatibility(trajectory) {
     }
   }
   if (trajectory.totalReward === undefined || Number.isNaN(trajectory.totalReward)) {
-    errors.push("Trajectory has no valid reward");
+    errors2.push("Trajectory has no valid reward");
   }
   const artTraj = toARTTrajectory(trajectory);
   if (artTraj.messages.length < 2) {
     warnings.push("Trajectory converts to very few messages (< 2)");
   }
   return {
-    valid: errors.length === 0,
-    errors,
+    valid: errors2.length === 0,
+    errors: errors2,
     warnings
   };
 }
@@ -1717,7 +3750,7 @@ async function buildGameStateFromDB(_trajectoryId) {
 }
 async function recomputeTrajectoryRewards(_trajectoryIds) {}
 // integration.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 async function startAutonomousTick(trajectoryLogger, context) {
   const trajectoryId = await trajectoryLogger.startTrajectory(context.agentId, {
     scenarioId: context.scenarioId,
@@ -1733,17 +3766,17 @@ async function startAutonomousTick(trajectoryLogger, context) {
     openPositions: 0
   };
   trajectoryLogger.startStep(trajectoryId, envState);
-  logger3.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
+  logger4.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
   return trajectoryId;
 }
 async function endAutonomousTick(trajectoryLogger, trajectoryId, status = "completed", finalMetrics) {
   await trajectoryLogger.endTrajectory(trajectoryId, status, finalMetrics);
-  logger3.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
+  logger4.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
 }
 async function loggedLLMCall(trajectoryLogger, trajectoryId, options, llmCallFn) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger3.warn({ trajectoryId }, "No active step for LLM call");
+    logger4.warn({ trajectoryId }, "No active step for LLM call");
     const result2 = await llmCallFn();
     return result2.text;
   }
@@ -1848,13 +3881,13 @@ class RewardService {
     return (score + 1) / 2;
   }
   normalizeScoresForGroup(scores) {
-    const min = Math.min(...scores);
-    const max = Math.max(...scores);
-    const range = max - min;
+    const min2 = Math.min(...scores);
+    const max2 = Math.max(...scores);
+    const range = max2 - min2;
     if (range === 0) {
       return scores.map(() => 0.5);
     }
-    return scores.map((s) => (s - min) / range);
+    return scores.map((s) => (s - min2) / range);
   }
 }
 function createRewardService(options = {}) {
@@ -1889,13 +3922,13 @@ var trajectoryLoggerPlugin = {
           };
         }
         const meta = message.metadata;
-        const logger4 = runtime.getService("trajectory_logger");
-        if (!logger4)
+        const logger5 = runtime.getService("trajectory_logger");
+        if (!logger5)
           return;
         let trajectoryStepId = crypto.randomUUID();
         meta.trajectoryStepId = trajectoryStepId;
         try {
-          const trajectoryId = await logger4.startTrajectory(runtime.agentId, {
+          const trajectoryId = await logger5.startTrajectory(runtime.agentId, {
             source: source ?? meta.source ?? "chat",
             metadata: {
               roomId: message.roomId,
@@ -1907,7 +3940,7 @@ var trajectoryLoggerPlugin = {
           });
           const normalizedTrajectoryId = typeof trajectoryId === "string" && trajectoryId.trim().length > 0 ? trajectoryId : null;
           if (normalizedTrajectoryId) {
-            const runtimeStepId = logger4.startStep(normalizedTrajectoryId, {
+            const runtimeStepId = logger5.startStep(normalizedTrajectoryId, {
               timestamp: Date.now(),
               agentBalance: 0,
               agentPoints: 0,
@@ -1945,12 +3978,12 @@ var trajectoryLoggerPlugin = {
         }
         if (!trajectoryStepId)
           return;
-        const logger4 = runtime.getService("trajectory_logger");
-        if (!logger4)
+        const logger5 = runtime.getService("trajectory_logger");
+        if (!logger5)
           return;
         try {
           const endTarget = pendingTrajectoryEndTargetByStepId.get(trajectoryStepId) ?? trajectoryStepId;
-          await logger4.endTrajectory(endTarget, "completed");
+          await logger5.endTrajectory(endTarget, "completed");
         } catch (err) {
           runtime.logger?.warn({
             err,
@@ -1990,7 +4023,7 @@ export {
   logProviderAccess,
   logLLMCallFromAction,
   groupTrajectories,
-  getTrajectoryContext,
+  getTrajectoryContext2 as getTrajectoryContext,
   extractSharedPrefix,
   exportToHuggingFace,
   exportGroupedForGRPO,
@@ -2007,4 +4040,4 @@ export {
   RewardService
 };
 
-//# debugId=C01EFBED6D31A62B64756E2164756E21
+//# debugId=07960868DB73CC4E64756E2164756E21