@anteros/core 0.0.44 → 0.0.47

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dnax Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -225,4 +225,4 @@ The server mounts **Socket.io** at `/socket.io/`. Route handlers receive the `io
 
 ## License
 
-See the parent repository for the project license.
+[MIT License](./LICENSE) — SPDX: `MIT`.

package/database/field.crypto.ts

@@ -40,6 +40,23 @@ export function encryptedPaths(col: Collection | null): PathField[] {
         }));
 }
 
+/**
+ * AAD context (#44): a ciphertext is bound to its tenant, collection and field.
+ * Legacy ciphertexts (no AAD) still decrypt through the fallback in `decryptStored`.
+ */
+function fieldAad(col: Collection | null, name: string): string {
+    return `${col?._tenant_ ?? "?"}:${col?.slug ?? "?"}:${name}`;
+}
+
+/** Try the contextual AAD first, then the legacy no-AAD ciphertexts. */
+async function decryptStored(cipher: any, value: string, aad: string): Promise<any> {
+    try {
+        return await cipher.decrypt(value, true, aad);
+    } catch {
+        return cipher.decrypt(value, true);
+    }
+}
+
 function requireConfig(col: Collection | null, targets: string[]) {
     if (!cfg.server.encryption?.mode) {
         throw new AppError(
@@ -67,16 +84,16 @@ function setPath(obj: Record<string, any>, path: string, value: any): void {
 }
 
 /** Encrypt the values at `paths` inside a json value — object or array of json objects */
-async function encryptAt(cipher: any, value: any, paths: string[]): Promise<any> {
+async function encryptAt(cipher: any, value: any, paths: string[], aad: string): Promise<any> {
     if (Array.isArray(value)) {
-        return Promise.all(value.map((item) => encryptAt(cipher, item, paths)));
+        return Promise.all(value.map((item) => encryptAt(cipher, item, paths, aad)));
     }
     if (!value || typeof value !== "object") return value;
     const out: Record<string, any> = { ...value };
     for (const p of paths) {
         const v = getPath(out, p);
         if (v !== undefined && v !== null) {
-            setPath(out, p, await cipher.encrypt(JSON.stringify(v))); // JSON-wrap → decrypt(..., true) round-trips any value
+            setPath(out, p, await cipher.encrypt(JSON.stringify(v), aad)); // JSON-wrap → decrypt(..., true) round-trips any value
         }
     }
     return out;
@@ -99,14 +116,14 @@ export async function encryptFields(col: Collection | null, data: Record<string,
     for (const name of names) {
         const v = out[name];
         if (v !== undefined && v !== null) {
-            out[name] = await cipher.encrypt(JSON.stringify(v));
+            out[name] = await cipher.encrypt(JSON.stringify(v), fieldAad(col, name));
         }
     }
     // Path fields (encryptionOptions.path) — encrypt only the sub-path(s)
     for (const { name, paths } of pathFields) {
         const v = out[name];
         if (v !== undefined && v !== null) {
-            out[name] = await encryptAt(cipher, v, paths);
+            out[name] = await encryptAt(cipher, v, paths, fieldAad(col, name));
         }
     }
     return out;
@@ -125,6 +142,13 @@ export async function encryptUpdate(col: Collection | null, update: Record<strin
     // Resolve a $set key → whole-field | sub-path of a path-field | null (not encrypted)
     const resolveKey = (k: string): { kind: "whole" | "path"; field: string; sub: string | null; paths?: string[] } | null => {
         if (nameSet.has(k)) return { kind: "whole", field: k, sub: null };
+        // Writing a sub-path of a whole encrypted field would store plaintext inside it (#44).
+        if (names.some((name) => k.startsWith(name + "."))) {
+            throw new AppError(
+                `Field '${k}' is a sub-path of an encrypted field — write the whole field instead`,
+                { code: "ENCRYPTED_FIELD_OPERATOR", status: 400 },
+            );
+        }
         const pf = pathFields.find((p) => k === p.name || k.startsWith(p.name + "."));
         if (pf) {
             const sub = k === pf.name ? null : k.slice(pf.name.length + 1);
@@ -149,14 +173,15 @@ export async function encryptUpdate(col: Collection | null, update: Record<strin
             for (const { k, hit } of hits) {
                 const v = newValues[k];
                 if (v === undefined || v === null) continue;
+                const aad = fieldAad(col, hit!.field);
                 if (hit!.kind === "whole") {
-                    newValues[k] = await cipher.encrypt(JSON.stringify(v));
+                    newValues[k] = await cipher.encrypt(JSON.stringify(v), aad);
                 } else if (hit!.sub === null) {
                     // whole json replacement → encrypt the configured paths inside
-                    newValues[k] = await encryptAt(cipher, v, hit!.paths!);
+                    newValues[k] = await encryptAt(cipher, v, hit!.paths!, aad);
                 } else {
                     // dot-notation leaf ('address.zip') → encrypt the value directly
-                    newValues[k] = await cipher.encrypt(JSON.stringify(v));
+                    newValues[k] = await cipher.encrypt(JSON.stringify(v), aad);
                 }
             }
             out[op] = newValues;
@@ -186,7 +211,7 @@ export async function decryptFields(col: Collection | null, doc: any): Promise<a
         const v = out[name];
         if (typeof v === "string") {
             try {
-                out[name] = await cipher.decrypt(v, true);
+                out[name] = await decryptStored(cipher, v, fieldAad(col, name));
             } catch {
                 // not a ciphertext (legacy plaintext) → keep as-is
             }
@@ -194,14 +219,14 @@ export async function decryptFields(col: Collection | null, doc: any): Promise<a
     }
     for (const { name, paths } of pathFields) {
         const v = out[name];
-        if (v && typeof v === "object") out[name] = await decryptAt(cipher, v, paths);
+        if (v && typeof v === "object") out[name] = await decryptAt(cipher, v, paths, fieldAad(col, name));
     }
     return out;
 }
 
-async function decryptAt(cipher: any, value: any, paths: string[]): Promise<any> {
+async function decryptAt(cipher: any, value: any, paths: string[], aad: string): Promise<any> {
     if (Array.isArray(value)) {
-        return Promise.all(value.map((item) => decryptAt(cipher, item, paths)));
+        return Promise.all(value.map((item) => decryptAt(cipher, item, paths, aad)));
     }
     if (!value || typeof value !== "object") return value;
     const out: Record<string, any> = { ...value };
@@ -209,7 +234,7 @@ async function decryptAt(cipher: any, value: any, paths: string[]): Promise<any>
         const v = getPath(out, p);
         if (typeof v === "string") {
             try {
-                setPath(out, p, await cipher.decrypt(v, true));
+                setPath(out, p, await decryptStored(cipher, v, aad));
             } catch {
                 // not a ciphertext → keep as-is
             }

package/database/mongodbadapter.ts

@@ -6,6 +6,29 @@ import type { MongoClientOptions, Db, ClientSession, UpdateOptions, UpdateFilter
  * Is a process still running **on this host**? `EPERM` means it exists but belongs
  * to another user — which still counts as alive.
  */
+/** Bulk operations embed their filter under the operation name — sanitize all of them (#45). */
+function assertBulkFilters(operations: any[]): void {
+    for (const operation of operations) {
+        func.assertSafeFilter(operation?.filter);
+        for (const value of Object.values(operation ?? {})) {
+            if (value && typeof value === "object") func.assertSafeFilter((value as any).filter);
+        }
+    }
+}
+
+/** `$rename` may not target a read-only field (#43) — the external API already refuses it. */
+function assertReadOnlyRename(col: any, update: any): void {
+    const rename = update?.$rename;
+    if (!rename || typeof rename !== "object") return;
+    const fields = (col?.api?.readOnlyFields ?? []) as (string | RegExp)[];
+    for (const target of Object.values(rename)) {
+        const name = String(target);
+        if (fields.some((field) => (typeof field === "string" ? field === name : field.test(name)))) {
+            throw new AppError(`Field '${name}' is read-only`, { status: 400, code: "READONLY_FIELD" });
+        }
+    }
+}
+
 function isProcessAlive(pid: number): boolean {
     if (!Number.isInteger(pid) || pid <= 0) return false;
     try {
@@ -15,6 +38,25 @@ function isProcessAlive(pid: number): boolean {
         return err?.code === 'EPERM';
     }
 }
+
+/**
+ * Resolve a collection definition or fail with the framework's own error.
+ *
+ * The `@CheckIfCollectionExists()` guard runs before the method, but the definition set
+ * can be replaced between the guard and the second lookup (a reload, or a deferred
+ * factory such as the query cache). Never cast `getCollection()` to `Collection` — a
+ * vanished definition would turn into `null is not an object (evaluating 'col.hooks')`.
+ */
+function requireCollection(collectionName: string, tenantId: string): Collection {
+    const col = getCollection(collectionName, tenantId)
+    if (!col) {
+        throw new AppError(`collection '${collectionName}' not found`, {
+            code: 'COLLECTION_NOT_FOUND',
+            status: 500,
+        })
+    }
+    return col
+}
 import { MongoClient, ObjectId, AggregationCursor } from "mongodb";
 import type { FindOptions, findOneOptions } from "../types/mongo";
 import type { FindCallOptions } from "../types/mongo";
@@ -27,7 +69,7 @@ import { getTenant } from "./tenant";
 import { getCollection, getCollectionKeys } from "./collection"
 import { AUDIT_COLLECTION } from "./audit"
 import { writeAuditFile } from "../lib/audit"
-import { redactPayload } from "../lib/redact"
+import { redactPayload, redactText } from "../lib/redact"
 import { summarizeAuditResult } from "../lib/auditResult"
 import { encryptFields, encryptUpdate } from "./field.crypto"
 import type { RestActions, BulkUpdateOperation, RestOptions, CursorOptions, TenantCache } from "../types/rest";
@@ -361,9 +403,10 @@ class MongoRest {
 
     @CheckIfCollectionExists()
     async watch(collection: string, pipeline: any[], options: ChangeStreamOptions): Promise<ChangeStream> {
+        func.boundMatchOperators(pipeline)
         // Audited with the parameters only — the change stream itself is a live object
         return this.#executeWithAudit('watch', collection, { pipeline, options }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
             const isSafe = func.isSafeAggregatePipeline(pipeline);
             if (!isSafe.isSafe) {
                 throw isSafe.error;
@@ -384,7 +427,7 @@ class MongoRest {
         const action = 'aggregate' as ActionsApiList
         return this.#executeReadWithAudit(action, collection, { pipeline }, async () => {
             try {
-                const col = getCollection(collection, this.#tenant.id) as Collection
+                const col = requireCollection(collection, this.#tenant.id)
                 // Flaw 12: restrict $lookup targets to this tenant's declared collections
                 const allowedCollections = [
                     ...(cfg.collections ?? [])
@@ -399,6 +442,7 @@ class MongoRest {
                 if (!isSafe.isSafe) {
                     throw isSafe.error;
                 }
+                func.boundMatchOperators(pipeline);
                 pipeline = func.toBson(pipeline, { col })
                 const meta: any = { action, collection, pipeline }
                 if (col.hooks?.beforeOperation) {
@@ -464,7 +508,7 @@ class MongoRest {
         const countPromise = withCount
             ? this.countDocuments(collection, params.$match ?? {})
             : null;
-        const col = getCollection(collection, this.#tenant.id) as Collection
+        const col = requireCollection(collection, this.#tenant.id)
         let pipeline = func.buildPipeline({ ...params, $limit: params.$limit ?? 0 }, { col: col })
         pipeline = await func.buildInput(pipeline, { rest: this })
         pipeline = func.toBson(pipeline, { col })
@@ -540,7 +584,7 @@ class MongoRest {
         // `break`/`return()` — which triggers the `finally` below). Parameters only.
         const start = Date.now();
         let failure: any = null;
-        const col = getCollection(collection, this.#tenant.id) as Collection
+        const col = requireCollection(collection, this.#tenant.id)
         const allowedCollections = [
             ...(cfg.collections ?? []).filter((c) => c._tenant_ === this.tenant_id).map((c) => c.slug),
             ...(cfg.fileCollections ?? []).filter((fc) => fc._tenant_ === this.tenant_id).map((fc) => fc.slug),
@@ -599,11 +643,13 @@ class MongoRest {
     @CheckIfCollectionExists()
     async find(collection: string, params: FindOptions = {}, options: FindCallOptions = {}): Promise<Document[]> {
         const action = 'find' as ActionsApiList
+        // Resolve once, before any await: a cache-miss factory may run later, after the
+        // definition set was replaced — the call keeps the collection it started with.
+        const col = requireCollection(collection, this.#tenant.id)
         return this.#executeReadWithAudit(action, collection, { params, options }, async () => {
             try {
                 // Real query — hooks + pipeline + toArray
                 const run = async (): Promise<Document[]> => {
-                    const col = getCollection(collection, this.#tenant.id) as Collection
                     let pipeline = func.buildPipeline(params, { col: col })
                     pipeline = await func.buildInput(pipeline, { rest: this })
                     pipeline = func.toBson(pipeline, { col })
@@ -644,7 +690,7 @@ class MongoRest {
         const action = 'findOne' as ActionsApiList
         return this.#executeReadWithAudit(action, collection, { id: _id, params }, async () => {
             try {
-                const col = getCollection(collection, this.#tenant.id) as Collection
+                const col = requireCollection(collection, this.#tenant.id)
                 let pipeline = func.buildPipeline({
                     ...params,
                     $match: { _id },
@@ -682,7 +728,7 @@ class MongoRest {
     async insertOne<T>(collection: string, data: T): Promise<T & { _id: string }> {
         const action = 'insertOne' as ActionsApiList
         return this.#executeWithAudit(action, collection, { data }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
 
             data = await func.buildInput(data as T, {
                 action: action, col: col, rest: this
@@ -719,7 +765,7 @@ class MongoRest {
     async insertMany<T>(collection: string, data: T[]): Promise<(T & { _id: string })[]> {
         const action = 'insertMany' as ActionsApiList
         return this.#executeWithAudit(action, collection, { count: data.length }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
             let dataInput: T[] = []
 
             for (let d of data) {
@@ -765,13 +811,14 @@ class MongoRest {
     async updateOne(collection: string, _id: string, update: UpdateFilter<any>) {
         const action = 'updateOne' as ActionsApiList
         return this.#executeWithAudit(action, collection, { id: _id, update }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
 
             if (update.$set) {
                 update.$set = await func.buildInput(update.$set, { action: action, col: col })
             }
 
             update = await func.buildInput(update)
+            assertReadOnlyRename(col, update)
             this._validate({ collection, action: action, update: update })
             // Field-level encryption: encrypt $set/$setOnInsert values for encrypted fields
             update = await encryptUpdate(col, update)
@@ -803,9 +850,10 @@ class MongoRest {
     @CheckIfCollectionExists()
     @CheckFilter()
     async findOneAndUpdate(collection: string, filter: Document, update: UpdateFilter<any>, options?: updateApiOptions): Promise<Document | null> {
+        func.assertSafeFilter(filter)
         const action = 'findOneAndUpdate' as ActionsApiList
         return this.#executeWithAudit(action, collection, { filter, update, options }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
 
 
 
@@ -875,12 +923,13 @@ class MongoRest {
     async updateMany(collection: string, _ids: string[], update: UpdateFilter<any>): Promise<UpdateResult> {
         const action = 'updateMany' as ActionsApiList
         return this.#executeWithAudit(action, collection, { ids: _ids, update }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
 
             if (update.$set) {
                 update.$set = await func.buildInput(update.$set, { action: action, col: col })
             }
             update = await func.buildInput(update)
+            assertReadOnlyRename(col, update)
             this._validate({ collection, action: action, update: update })
             // Field-level encryption: encrypt $set/$setOnInsert values for encrypted fields
             update = await encryptUpdate(col, update)
@@ -912,7 +961,7 @@ class MongoRest {
     async deleteOne(collection: string, _id: string) {
         const action = 'deleteOne' as ActionsApiList
         return this.#executeWithAudit(action, collection, { id: _id }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
 
             const meta: any = { action, collection, id: _id }
             if (col.hooks?.beforeOperation) {
@@ -941,7 +990,7 @@ class MongoRest {
     async deleteMany(collection: string, _ids: string[]): Promise<DeleteResult> {
         const action = 'deleteMany' as ActionsApiList
         return this.#executeWithAudit(action, collection, { ids: _ids }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
 
             const meta: any = { action, collection, ids: _ids }
             if (col.hooks?.beforeOperation) {
@@ -968,10 +1017,11 @@ class MongoRest {
     @CheckIfCollectionExists()
     @CheckBulkWriteOperations()
     async bulkWrite(collection: string, operations: AnyBulkWriteOperation[], options?: BulkWriteOptions): Promise<BulkWriteResult> {
+        assertBulkFilters(operations);
         const action = 'bulkWrite' as ActionsApiList
         return this.#executeWithAudit(action, collection, { count: operations.length }, async () => {
             for (let operation of operations) {
-                const col = getCollection(collection, this.#tenant.id) as Collection
+                const col = requireCollection(collection, this.#tenant.id)
 
                 if ('insertOne' in operation) {
                     operation.insertOne.document = func.toBson(
@@ -1034,9 +1084,10 @@ class MongoRest {
     @LogSlowQuery()
     @CheckIfCollectionExists()
     async bulkUpdate(collection: string, operations: BulkUpdateOperation[], options?: BulkWriteOptions): Promise<BulkWriteResult> {
+        assertBulkFilters(operations);
         const action = 'bulkUpdate' as ActionsApiList
         return this.#executeWithAudit(action, collection, { count: operations.length }, async () => {
-            const col = getCollection(collection, this.#tenant.id) as Collection
+            const col = requireCollection(collection, this.#tenant.id)
 
             for (const operation of operations) {
                 if ('updateOne' in operation) {
@@ -1069,6 +1120,7 @@ class MongoRest {
     @LogSlowQuery()
     @CheckIfCollectionExists()
     async countDocuments(collection: string, query: any = {}): Promise<number> {
+        func.assertSafeFilter(query)
         const action = 'countDocuments' as ActionsApiList
         return this.#executeWithAudit(action, collection, { query }, async () => {
             // ⚠️ must pass the filter — countDocuments() without args counts the whole collection
@@ -1275,18 +1327,26 @@ class MongoRest {
                 // here (`server.audit.redact`), whatever wrote the entry — including a
                 // direct `rest.audit.addActivities()` call. Never store a password,
                 // token or secret in clear, in `_audit_` or in the local file.
-                const entries = activities.map((activity) => ({
-                    ...activity,
-                    // `request` (headers, query string) is attacker-controlled too — it
-                    // carries `x-api-key`, `?token=…`, … just like a payload
-                    request: redactPayload(activity?.request),
-                    meta: redactPayload(activity?.meta),
-                    operation: {
+                const entries = activities.map((activity) => {
+                    const operation: any = {
                         ...activity?.operation,
                         input: redactPayload(activity?.operation?.input),
                         result: redactPayload(activity?.operation?.result),
-                    },
-                }))
+                        error: redactPayload(activity?.operation?.error),
+                        token: redactPayload(activity?.operation?.token),
+                    };
+                    if (typeof operation.error?.message === "string") {
+                        operation.error = { ...operation.error, message: redactText(operation.error.message) };
+                    }
+                    return {
+                        ...activity,
+                        // `request` (headers, query string) is attacker-controlled too — it
+                        // carries `x-api-key`, `?token=…`, … just like a payload
+                        request: redactPayload(activity?.request),
+                        meta: redactPayload(activity?.meta),
+                        operation,
+                    };
+                })
                 await this.db.collection(AUDIT_COLLECTION).insertMany(entries)
                     .then(e => e)
                     .catch(err => {

package/database/vars.ts

@@ -50,6 +50,9 @@ function varId(scope: string | null, ns: string, key: string): string {
 
 function scopeToString(scope: any): string | null {
     if (scope === undefined || scope === null || scope === "") return null;
+    if (typeof scope === "object" && !(scope instanceof ObjectId)) {
+        throw new AppError("[vars] scope must be a string, a number or an id", { code: "VALIDATION_ERROR", status: 400 });
+    }
     return String(scope);
 }
 
@@ -91,7 +94,15 @@ function validateMeta(def: Compiled | undefined, meta: any): Record<string, any>
 /** Validate (and normalize) the scope value, using the namespace's `scope` field when declared. */
 function validateScope(def: Compiled | undefined, scope: any): any {
     if (scope === undefined || scope === null || scope === "") return null;
-    if (!def?.scope) return scope;
+    if (!def?.scope) {
+        // No declared scope: only a **primitive** may name one. Returning the raw
+        // value let a caller pass a Mongo operator (`{"$ne": null}`) that
+        // `findEntries` / `clear` then used as a filter — cross-scope read/delete.
+        if (typeof scope === "string") return scope;
+        if (typeof scope === "number" || typeof scope === "bigint") return String(scope);
+        if (typeof scope === "object" && scope instanceof ObjectId) return scope;
+        throw validationError(def?.namespace ?? "?", "scope must be a string or a number");
+    }
     const schema = fieldToSchema(def.scope);
     const { error, value } = schema!.validate(scope);
     if (error) throw validationError(def.namespace, `${def.scope.name} — ${error.message}`);
@@ -164,7 +175,16 @@ function createVars(tenantId: string, boundScope?: any): TenantVars {
     const findEntries = async (ns: string, opts?: VarsAllOptions): Promise<any[]> => {
         const scope = resolveScope(ns, opts);
         const where = opts?.where ?? {};
-        const metaFilter = Object.fromEntries(Object.entries(where).map(([k, v]) => [`meta.${k}`, v]));
+        const metaFilter: Record<string, any> = {};
+        for (const [field, value] of Object.entries(where)) {
+            if (field.startsWith("$")) throw validationError(ns, `invalid where field '${field}'`);
+            const primitive = value === null
+                || ["string", "number", "boolean", "bigint"].includes(typeof value)
+                || value instanceof Date
+                || value instanceof ObjectId;
+            if (!primitive) throw validationError(ns, `invalid where value for '${field}'`);
+            metaFilter[`meta.${field}`] = value;
+        }
         return await col().find({ ns, scope: scope.value, ...metaFilter, ...alive() }).toArray();
     };
 

package/index.ts

@@ -6,9 +6,11 @@ import { useRest } from "./database/rest";
 import { AppError } from "./lib/error";
 import { Agent } from "./lib/agent";
 import { agents } from "./lib/agents";
+import { evaluateAgent } from "./lib/eval";
 import { endpoints } from "./lib/endpoints";
 import * as v from "joi";
 import utils from "./utils";
+import {ObjectId} from "mongodb"
 
 
 
@@ -46,5 +48,25 @@ export {
     logger,
     Agent,
     agents,
+    evaluateAgent,
     endpoints,
+    ObjectId
 }
+
+export type {
+    AgentMemoryContext,
+    AgentRecallHit,
+    AgentRecallQuery,
+    AgentRecallRecord,
+    AgentRunState,
+    AgentRunStore,
+    AgentSemanticRecallOptions,
+    AgentTraceEvent,
+} from "./types/agent";
+
+export type {
+    AgentEvalCase,
+    AgentEvalCaseReport,
+    AgentEvalGrader,
+    AgentEvalReport,
+} from "./lib/eval";