mentedb 0.11.10 → 0.11.12

package/npm/client.d.ts

@@ -1,4 +1,4 @@
-import { EdgeType, type StoreOptions, type RecallResult, type SearchResult } from './types';
+import { EdgeType, type StoreOptions, type RecallResult, type SearchResult, type ProcessTurnResult, type IngestResult } from './types';
 /**
  * MenteDB client. Wraps the native Rust database engine and exposes a
  * TypeScript-friendly API for storing, recalling, searching, relating, and
@@ -7,6 +7,27 @@ import { EdgeType, type StoreOptions, type RecallResult, type SearchResult } fro
 export declare class MenteDB {
     private native;
     constructor(dataDir?: string);
+    /**
+     * Process one conversation turn through the full cognitive pipeline.
+     *
+     * This is the primary API. A single call embeds the message, runs hybrid
+     * recall (vector + keyword + graph), stores the turn, extracts facts,
+     * detects contradictions, and returns attention-ordered context plus what
+     * was learned. The field you use most is `context`: inject those memories
+     * into your next prompt.
+     *
+     * Fact extraction and contradiction detection require an LLM. Set
+     * `MENTEDB_LLM_PROVIDER` and `MENTEDB_LLM_API_KEY` in the environment;
+     * without them you still get storage and recall.
+     */
+    processTurn(userMessage: string, assistantResponse?: string, turnId?: number, projectContext?: string, agentId?: string, sessionId?: string): ProcessTurnResult;
+    /**
+     * Extract memories from a raw conversation transcript and store them.
+     *
+     * Requires an LLM. Set `MENTEDB_LLM_PROVIDER` and `MENTEDB_LLM_API_KEY`,
+     * or pass `provider` ("openai", "anthropic", or "ollama") explicitly.
+     */
+    ingest(conversation: string, provider?: string, agentId?: string): IngestResult;
     /** Store a memory and return its UUID. */
     store(options: StoreOptions): string;
     /** Recall memories using an MQL query string. */

package/npm/client.js

@@ -74,6 +74,31 @@ class MenteDB {
     constructor(dataDir = './mentedb-data') {
         this.native = new nativeBinding.MenteDb(dataDir);
     }
+    /**
+     * Process one conversation turn through the full cognitive pipeline.
+     *
+     * This is the primary API. A single call embeds the message, runs hybrid
+     * recall (vector + keyword + graph), stores the turn, extracts facts,
+     * detects contradictions, and returns attention-ordered context plus what
+     * was learned. The field you use most is `context`: inject those memories
+     * into your next prompt.
+     *
+     * Fact extraction and contradiction detection require an LLM. Set
+     * `MENTEDB_LLM_PROVIDER` and `MENTEDB_LLM_API_KEY` in the environment;
+     * without them you still get storage and recall.
+     */
+    processTurn(userMessage, assistantResponse, turnId = 0, projectContext, agentId, sessionId) {
+        return this.native.processTurn(userMessage, assistantResponse ?? null, turnId, projectContext ?? null, agentId ?? null, sessionId ?? null);
+    }
+    /**
+     * Extract memories from a raw conversation transcript and store them.
+     *
+     * Requires an LLM. Set `MENTEDB_LLM_PROVIDER` and `MENTEDB_LLM_API_KEY`,
+     * or pass `provider` ("openai", "anthropic", or "ollama") explicitly.
+     */
+    ingest(conversation, provider, agentId) {
+        return this.native.ingest(conversation, provider ?? null, agentId ?? null);
+    }
     /** Store a memory and return its UUID. */
     store(options) {
         const { content, memoryType = types_1.MemoryType.Episodic, embedding = [], agentId, tags, } = options;

package/npm/types.d.ts

@@ -32,3 +32,58 @@ export interface StoreOptions {
     agentId?: string;
     tags?: string[];
 }
+/** A single memory selected for the working-context window. */
+export interface ContextItem {
+    id: string;
+    content: string;
+    score: number;
+}
+export interface PainWarning {
+    signalId: string;
+    intensity: number;
+    description: string;
+}
+export interface DetectedAction {
+    actionType: string;
+    detail: string;
+}
+export interface ProactiveRecall {
+    memoryId: string;
+    content: string;
+    relevance: number;
+    actionType: string;
+}
+/**
+ * Everything one `processTurn` call produced. The field you use most is
+ * `context`: the attention-ordered memories to inject into your next prompt.
+ */
+export interface ProcessTurnResult {
+    /** Attention-ordered memories relevant to this turn. Inject into your next prompt. */
+    context: ContextItem[];
+    /** IDs of the memories stored from this turn. */
+    storedIds: string[];
+    episodicId?: string;
+    painWarnings: PainWarning[];
+    cacheHit: boolean;
+    inferenceActions: number;
+    detectedActions: DetectedAction[];
+    proactiveRecalls: ProactiveRecall[];
+    correctionId?: string;
+    sentiment: number;
+    phantomCount: number;
+    contradictionCount: number;
+    predictedTopics: string[];
+    /** Facts extracted this turn. Zero unless an LLM is configured (see MENTEDB_LLM_PROVIDER). */
+    factsExtracted: number;
+    edgesCreated: number;
+    enrichmentPending: boolean;
+    deltaAdded: string[];
+    deltaRemoved: string[];
+}
+export interface IngestResult {
+    memoriesStored: number;
+    rejectedLowQuality: number;
+    rejectedDuplicate: number;
+    contradictions: number;
+    storedIds: string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mentedb",
-  "version": "0.11.10",
+  "version": "0.11.12",
   "description": "The mind database for AI agents",
   "main": "npm/index.js",
   "types": "npm/index.d.ts",