audrey 0.16.0 → 0.17.0

package/src/audrey.js

@@ -44,6 +44,7 @@ import { detectResonance } from './affect.js';
  * @property {string} [before]
  * @property {Record<string, string>} [context]
  * @property {{ valence?: number, arousal?: number }} [mood]
+ * @property {'hybrid' | 'vector' | 'keyword'} [retrieval]
  *
  * @typedef {Object} RecallResult
  * @property {string} id
@@ -118,6 +119,7 @@ export class Audrey extends EventEmitter {
     const { db, migrated } = createDatabase(dataDir, { dimensions: this.embeddingProvider.dimensions });
     this.db = db;
     this._migrationPending = migrated;
+    this._pending = new Set();
     this.llmProvider = llm ? createLLMProvider(llm) : null;
     this.confidenceConfig = {
       weights: confidence.weights,
@@ -128,10 +130,11 @@ export class Audrey extends EventEmitter {
       affectWeight: affect.weight ?? 0.2,
     };
     this.consolidationConfig = {
-      minEpisodes: consolidation.minEpisodes || 3,
+      minEpisodes: consolidation.minEpisodes ?? 3,
     };
-    this.decayConfig = { dormantThreshold: decay.dormantThreshold || 0.1 };
+    this.decayConfig = { dormantThreshold: decay.dormantThreshold ?? 0.1 };
     this._autoConsolidateTimer = null;
+    this._closed = false;
     this.interferenceConfig = {
       enabled: interference.enabled ?? true,
       k: interference.k ?? 5,
@@ -163,8 +166,19 @@ export class Audrey extends EventEmitter {
     this.emit('migration', counts);
   }
 
+  _trackAsync(promise) {
+    this._pending.add(promise);
+    promise.finally(() => this._pending.delete(promise));
+  }
+
+  async waitForIdle() {
+    while (this._pending.size > 0) {
+      await Promise.allSettled([...this._pending]);
+    }
+  }
+
   _emitValidation(id, params) {
-    validateMemory(this.db, this.embeddingProvider, { id, ...params }, {
+    const p = validateMemory(this.db, this.embeddingProvider, { id, ...params }, {
       llmProvider: this.llmProvider,
     })
       .then(validation => {
@@ -184,7 +198,8 @@ export class Audrey extends EventEmitter {
           });
         }
       })
-      .catch(err => this.emit('error', err));
+      .catch(err => { if (!this._closed) this.emit('error', err); });
+    this._trackAsync(p);
   }
 
   /**
@@ -193,26 +208,28 @@ export class Audrey extends EventEmitter {
    */
   async encode(params) {
     await this._ensureMigrated();
-    const encodeParams = { ...params, arousalWeight: this.affectConfig.arousalWeight };
+    const encodeParams = { agent: this.agent, ...params, arousalWeight: this.affectConfig.arousalWeight };
     const id = await encodeEpisode(this.db, this.embeddingProvider, encodeParams);
     this.emit('encode', { id, ...params });
     if (this.interferenceConfig.enabled) {
-      applyInterference(this.db, this.embeddingProvider, id, params, this.interferenceConfig)
+      const p = applyInterference(this.db, this.embeddingProvider, id, params, this.interferenceConfig)
         .then(affected => {
           if (affected.length > 0) {
             this.emit('interference', { episodeId: id, affected });
           }
         })
-        .catch(err => this.emit('error', err));
+        .catch(err => { if (!this._closed) this.emit('error', err); });
+      this._trackAsync(p);
     }
     if (this.affectConfig.enabled && this.affectConfig.resonance.enabled && params.affect?.valence !== undefined) {
-      detectResonance(this.db, this.embeddingProvider, id, params, this.affectConfig.resonance)
+      const p = detectResonance(this.db, this.embeddingProvider, id, params, this.affectConfig.resonance)
         .then(echoes => {
           if (echoes.length > 0) {
             this.emit('resonance', { episodeId: id, affect: params.affect, echoes });
           }
         })
-        .catch(err => this.emit('error', err));
+        .catch(err => { if (!this._closed) this.emit('error', err); });
+      this._trackAsync(p);
     }
     this._emitValidation(id, params);
     return id;
@@ -288,6 +305,7 @@ export class Audrey extends EventEmitter {
   async recall(query, options = {}) {
     await this._ensureMigrated();
     return recallFn(this.db, this.embeddingProvider, query, {
+      agent: this.agent,
       ...options,
       confidenceConfig: this._recallConfig(options),
     });
@@ -301,6 +319,7 @@ export class Audrey extends EventEmitter {
   async *recallStream(query, options = {}) {
     await this._ensureMigrated();
     yield* recallStreamFn(this.db, this.embeddingProvider, query, {
+      agent: this.agent,
       ...options,
       confidenceConfig: this._recallConfig(options),
     });
@@ -324,8 +343,8 @@ export class Audrey extends EventEmitter {
   async consolidate(options = {}) {
     await this._ensureMigrated();
     const result = await runConsolidation(this.db, this.embeddingProvider, {
-      minClusterSize: options.minClusterSize || this.consolidationConfig.minEpisodes,
-      similarityThreshold: options.similarityThreshold || 0.80,
+      minClusterSize: options.minClusterSize ?? this.consolidationConfig.minEpisodes,
+      similarityThreshold: options.similarityThreshold ?? 0.80,
       extractPrinciple: options.extractPrinciple,
       llmProvider: options.llmProvider || this.llmProvider,
     });
@@ -341,7 +360,7 @@ export class Audrey extends EventEmitter {
    */
   decay(options = {}) {
     const result = applyDecay(this.db, {
-      dormantThreshold: options.dormantThreshold || this.decayConfig.dormantThreshold,
+      dormantThreshold: options.dormantThreshold ?? this.decayConfig.dormantThreshold,
       halfLives: options.halfLives ?? this.confidenceConfig.halfLives,
     });
     this.emit('decay', result);
@@ -564,6 +583,9 @@ export class Audrey extends EventEmitter {
     this._autoConsolidateTimer = setInterval(() => {
       this.consolidate(options).catch(err => this.emit('error', err));
     }, intervalMs);
+    if (typeof this._autoConsolidateTimer.unref === 'function') {
+      this._autoConsolidateTimer.unref();
+    }
   }
 
   stopAutoConsolidate() {
@@ -583,6 +605,20 @@ export class Audrey extends EventEmitter {
     return result;
   }
 
+  markUsed(id) {
+    const now = new Date().toISOString();
+    const tables = ['episodes', 'semantics', 'procedures'];
+    for (const table of tables) {
+      const result = this.db.prepare(
+        `UPDATE ${table} SET usage_count = usage_count + 1, last_used_at = ? WHERE id = ?`
+      ).run(now, id);
+      if (result.changes > 0) {
+        this.emit('used', { id, table, usageCount: result.changes });
+        return;
+      }
+    }
+  }
+
   async forgetByQuery(query, options = {}) {
     await this._ensureMigrated();
     const result = await forgetByQueryFn(this.db, this.embeddingProvider, query, options);
@@ -596,9 +632,11 @@ export class Audrey extends EventEmitter {
     return result;
   }
 
-  /** @returns {void} */
   close() {
+    if (this._closed) return;
+    this._closed = true;
     this.stopAutoConsolidate();
+    this._pending.clear();
     closeDatabase(this.db);
   }
 }

package/src/consolidate.js

@@ -97,6 +97,10 @@ async function llmExtractPrinciple(llmProvider, episodes) {
   return llmProvider.json(messages);
 }
 
+function inClause(ids) {
+  return ids.map(() => '?').join(',');
+}
+
 /**
  * @param {import('better-sqlite3').Database} db
  * @param {import('./embedding.js').EmbeddingProvider} embeddingProvider
@@ -132,6 +136,7 @@ export async function runConsolidation(db, embeddingProvider, options = {}) {
     const allOutputIds = [];
     let principlesExtracted = 0;
     let proceduresExtracted = 0;
+    const preparedClusters = [];
     const insertProcedure = db.prepare(`
       INSERT INTO procedures (
         id, content, embedding, state, trigger_conditions,
@@ -149,8 +154,6 @@ export async function runConsolidation(db, embeddingProvider, options = {}) {
       ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     const insertVecSemantic = db.prepare('INSERT INTO vec_semantics(id, embedding, state) VALUES (?, ?, ?)');
-    const markEpisode = db.prepare('UPDATE episodes SET consolidated = 1 WHERE id = ?');
-    const markVecEpisode = db.prepare('UPDATE vec_episodes SET consolidated = ? WHERE id = ?');
     const updateRunCompleted = db.prepare(`
       UPDATE consolidation_runs
       SET status = 'completed',
@@ -165,70 +168,88 @@ export async function runConsolidation(db, embeddingProvider, options = {}) {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      for (const cluster of clusters) {
-        let principle;
-        if (extractPrinciple) {
-          principle = extractPrinciple(cluster);
-        } else if (llmProvider) {
-          principle = await llmExtractPrinciple(llmProvider, cluster);
-        } else {
-          principle = defaultExtractPrinciple(cluster);
-        }
+    for (const cluster of clusters) {
+      let principle;
+      if (extractPrinciple) {
+        principle = await extractPrinciple(cluster);
+      } else if (llmProvider) {
+        principle = await llmExtractPrinciple(llmProvider, cluster);
+      } else {
+        principle = defaultExtractPrinciple(cluster);
+      }
 
-        if (!principle || !principle.content) continue;
+      if (!principle || !principle.content) continue;
 
-        const clusterIds = cluster.map(ep => ep.id);
-        const sourceTypeDiversity = new Set(cluster.map(ep => ep.source)).size;
-        const vector = await embeddingProvider.embed(principle.content);
-        const embeddingBuffer = embeddingProvider.vectorToBuffer(vector);
-        const memoryId = generateId();
-        const createdAt = new Date().toISOString();
-        const maxSalience = Math.max(...cluster.map(ep => ep.salience ?? 0.5));
+      const vector = await embeddingProvider.embed(principle.content);
+      const clusterIds = cluster.map(ep => ep.id);
+      preparedClusters.push({
+        principle,
+        clusterIds,
+        sourceTypeDiversity: new Set(cluster.map(ep => ep.source)).size,
+        embeddingBuffer: embeddingProvider.vectorToBuffer(vector),
+        memoryId: generateId(),
+        createdAt: new Date().toISOString(),
+        maxSalience: Math.max(...cluster.map(ep => ep.salience ?? 0.5)),
+      });
+    }
 
-        allInputIds.push(...clusterIds);
+    const writeConsolidation = db.transaction(() => {
+      for (const prepared of preparedClusters) {
+        const placeholders = inClause(prepared.clusterIds);
+        const eligibleCount = db.prepare(`
+          SELECT COUNT(*) AS count
+          FROM episodes
+          WHERE id IN (${placeholders})
+            AND consolidated = 0
+            AND superseded_by IS NULL
+        `).get(...prepared.clusterIds).count;
 
-        if (principle.type === 'procedural') {
+        if (eligibleCount !== prepared.clusterIds.length) {
+          continue;
+        }
+
+        if (prepared.principle.type === 'procedural') {
           insertProcedure.run(
-            memoryId,
-            principle.content,
-            embeddingBuffer,
-            principle.conditions ? JSON.stringify(principle.conditions) : null,
-            JSON.stringify(clusterIds),
+            prepared.memoryId,
+            prepared.principle.content,
+            prepared.embeddingBuffer,
+            prepared.principle.conditions ? JSON.stringify(prepared.principle.conditions) : null,
+            JSON.stringify(prepared.clusterIds),
             embeddingProvider.modelName,
             embeddingProvider.modelVersion,
-            createdAt,
-            maxSalience,
+            prepared.createdAt,
+            prepared.maxSalience,
           );
-          insertVecProcedure.run(memoryId, embeddingBuffer, 'active');
+          insertVecProcedure.run(prepared.memoryId, prepared.embeddingBuffer, 'active');
           proceduresExtracted++;
         } else {
           insertSemantic.run(
-            memoryId,
-            principle.content,
-            embeddingBuffer,
-            JSON.stringify(clusterIds),
-            cluster.length,
-            cluster.length,
-            sourceTypeDiversity,
+            prepared.memoryId,
+            prepared.principle.content,
+            prepared.embeddingBuffer,
+            JSON.stringify(prepared.clusterIds),
+            prepared.clusterIds.length,
+            prepared.clusterIds.length,
+            prepared.sourceTypeDiversity,
             runId,
             embeddingProvider.modelName,
             embeddingProvider.modelVersion,
             llmProvider?.modelName || null,
-            createdAt,
-            maxSalience,
+            prepared.createdAt,
+            prepared.maxSalience,
           );
-          insertVecSemantic.run(memoryId, embeddingBuffer, 'active');
+          insertVecSemantic.run(prepared.memoryId, prepared.embeddingBuffer, 'active');
         }
 
-        allOutputIds.push(memoryId);
-        principlesExtracted++;
+        db.prepare(`UPDATE episodes SET consolidated = 1 WHERE id IN (${placeholders})`).run(...prepared.clusterIds);
+        db.prepare(`UPDATE vec_episodes SET consolidated = ? WHERE id IN (${placeholders})`).run(
+          BigInt(1),
+          ...prepared.clusterIds,
+        );
 
-        for (const ep of cluster) {
-          markEpisode.run(ep.id);
-          markVecEpisode.run(BigInt(1), ep.id);
-        }
+        allInputIds.push(...prepared.clusterIds);
+        allOutputIds.push(prepared.memoryId);
+        principlesExtracted++;
       }
 
       const completedAt = new Date().toISOString();
@@ -237,13 +258,8 @@ export async function runConsolidation(db, embeddingProvider, options = {}) {
         generateId(), runId, minClusterSize, similarityThreshold,
         episodesEvaluated, clusters.length, principlesExtracted, completedAt,
       );
-      db.exec('COMMIT');
-    } catch (err) {
-      if (db.inTransaction) {
-        db.exec('ROLLBACK');
-      }
-      throw err;
-    }
+    });
+    writeConsolidation.immediate();
 
     return {
       runId,

package/src/db.js

@@ -2,6 +2,7 @@ import Database from 'better-sqlite3';
 import * as sqliteVec from 'sqlite-vec';
 import { join } from 'node:path';
 import { mkdirSync, existsSync } from 'node:fs';
+import { createFTSTables, backfillFTS } from './fts.js';
 
 const SCHEMA = `
   CREATE TABLE IF NOT EXISTS episodes (
@@ -248,7 +249,7 @@ function addColumnIfMissing(db, table, column, definition) {
   }
 }
 
-const SCHEMA_VERSION = 7;
+const SCHEMA_VERSION = 10;
 
 const MIGRATIONS = [
   { version: 1, up(db) { addColumnIfMissing(db, 'episodes', 'context', "TEXT DEFAULT '{}'"); } },
@@ -258,6 +259,26 @@ const MIGRATIONS = [
   { version: 5, up(db) { addColumnIfMissing(db, 'procedures', 'interference_count', 'INTEGER DEFAULT 0'); } },
   { version: 6, up(db) { addColumnIfMissing(db, 'procedures', 'salience', 'REAL DEFAULT 0.5'); } },
   { version: 7, up(db) { addColumnIfMissing(db, 'episodes', 'private', 'INTEGER DEFAULT 0'); } },
+  { version: 8, up(db) {
+    addColumnIfMissing(db, 'episodes', 'agent', "TEXT DEFAULT 'default'");
+    addColumnIfMissing(db, 'semantics', 'agent', "TEXT DEFAULT 'default'");
+    addColumnIfMissing(db, 'procedures', 'agent', "TEXT DEFAULT 'default'");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_episodes_agent ON episodes(agent)");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_semantics_agent ON semantics(agent)");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_procedures_agent ON procedures(agent)");
+  }},
+  { version: 9, up(db) {
+    createFTSTables(db);
+    backfillFTS(db);
+  }},
+  { version: 10, up(db) {
+    addColumnIfMissing(db, 'episodes', 'usage_count', 'INTEGER DEFAULT 0');
+    addColumnIfMissing(db, 'episodes', 'last_used_at', 'TEXT');
+    addColumnIfMissing(db, 'semantics', 'usage_count', 'INTEGER DEFAULT 0');
+    addColumnIfMissing(db, 'semantics', 'last_used_at', 'TEXT');
+    addColumnIfMissing(db, 'procedures', 'usage_count', 'INTEGER DEFAULT 0');
+    addColumnIfMissing(db, 'procedures', 'last_used_at', 'TEXT');
+  }},
 ];
 
 function runMigrations(db) {

package/src/embedding.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { describeHttpError, requireApiKey } from './utils.js';
 
 /**
  * @typedef {Object} EmbeddingProvider
@@ -54,6 +55,7 @@ export class OpenAIEmbeddingProvider {
   }
 
   async embed(text) {
+    requireApiKey(this.apiKey, 'OpenAI embedding', 'OPENAI_API_KEY');
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeout);
     try {
@@ -66,7 +68,7 @@ export class OpenAIEmbeddingProvider {
         body: JSON.stringify({ input: text, model: this.model, dimensions: this.dimensions }),
         signal: controller.signal,
       });
-      if (!response.ok) throw new Error(`OpenAI embedding failed: ${response.status}`);
+      if (!response.ok) throw new Error(`OpenAI embedding failed: ${await describeHttpError(response)}`);
       const data = await response.json();
       return data.data[0].embedding;
     } finally {
@@ -75,6 +77,7 @@ export class OpenAIEmbeddingProvider {
   }
 
   async embedBatch(texts) {
+    requireApiKey(this.apiKey, 'OpenAI embedding', 'OPENAI_API_KEY');
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeout);
     try {
@@ -87,7 +90,7 @@ export class OpenAIEmbeddingProvider {
         body: JSON.stringify({ input: texts, model: this.model, dimensions: this.dimensions }),
         signal: controller.signal,
       });
-      if (!response.ok) throw new Error(`OpenAI embedding failed: ${response.status}`);
+      if (!response.ok) throw new Error(`OpenAI embedding failed: ${await describeHttpError(response)}`);
       const data = await response.json();
       return data.data.map(d => d.embedding);
     } finally {
@@ -106,13 +109,14 @@ export class OpenAIEmbeddingProvider {
 
 /** @implements {EmbeddingProvider} */
 export class LocalEmbeddingProvider {
-  constructor({ model = 'Xenova/all-MiniLM-L6-v2', device = 'gpu', batchSize = 64 } = {}) {
+  constructor({ model = 'Xenova/all-MiniLM-L6-v2', device = 'gpu', batchSize = 64, pipelineFactory = null } = {}) {
     this.model = model;
     this.dimensions = 384;
     this.modelName = model;
     this.modelVersion = '1.0.0';
     this.device = device;
     this.batchSize = batchSize;
+    this.pipelineFactory = pipelineFactory;
     this._pipeline = null;
     this._readyPromise = null;
     this._actualDevice = null;
@@ -121,7 +125,7 @@ export class LocalEmbeddingProvider {
   ready() {
     if (!this._readyPromise) {
       this._readyPromise = (async () => {
-        const { pipeline } = await import('@huggingface/transformers');
+        const pipeline = this.pipelineFactory || (await import('@huggingface/transformers')).pipeline;
         try {
           this._pipeline = await pipeline('feature-extraction', this.model, {
             dtype: 'fp32', device: this.device,
@@ -177,20 +181,20 @@ export class GeminiEmbeddingProvider {
   }
 
   async embed(text) {
-    if (!this.apiKey) throw new Error('Gemini embedding requires GOOGLE_API_KEY');
+    requireApiKey(this.apiKey, 'Gemini embedding', 'GOOGLE_API_KEY');
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeout);
     try {
       const response = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:embedContent?key=${this.apiKey}`,
+        `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:embedContent`,
         {
           method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
+          headers: { 'Content-Type': 'application/json', 'x-goog-api-key': this.apiKey },
           body: JSON.stringify({ model: `models/${this.model}`, content: { parts: [{ text }] } }),
           signal: controller.signal,
         }
       );
-      if (!response.ok) throw new Error(`Gemini embedding failed: ${response.status}`);
+      if (!response.ok) throw new Error(`Gemini embedding failed: ${await describeHttpError(response)}`);
       const data = await response.json();
       return data.embedding.values;
     } finally {
@@ -200,7 +204,7 @@ export class GeminiEmbeddingProvider {
 
   async embedBatch(texts) {
     if (texts.length === 0) return [];
-    if (!this.apiKey) throw new Error('Gemini embedding requires GOOGLE_API_KEY');
+    requireApiKey(this.apiKey, 'Gemini embedding', 'GOOGLE_API_KEY');
     const results = [];
     for (let i = 0; i < texts.length; i += 100) {
       const chunk = texts.slice(i, i + 100);
@@ -208,10 +212,10 @@ export class GeminiEmbeddingProvider {
       const timer = setTimeout(() => controller.abort(), this.timeout);
       try {
         const response = await fetch(
-          `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:batchEmbedContents?key=${this.apiKey}`,
+          `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:batchEmbedContents`,
           {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: { 'Content-Type': 'application/json', 'x-goog-api-key': this.apiKey },
             body: JSON.stringify({
               requests: chunk.map(text => ({
                 model: `models/${this.model}`,
@@ -221,7 +225,7 @@ export class GeminiEmbeddingProvider {
             signal: controller.signal,
           }
         );
-        if (!response.ok) throw new Error(`Gemini batch embedding failed: ${response.status}`);
+        if (!response.ok) throw new Error(`Gemini batch embedding failed: ${await describeHttpError(response)}`);
         const data = await response.json();
         results.push(...data.embeddings.map(e => e.values));
       } finally {

package/src/encode.js

@@ -1,6 +1,7 @@
 import { generateId } from './ulid.js';
 import { sourceReliability } from './confidence.js';
 import { arousalSalienceBoost } from './affect.js';
+import { hasFTSTables, insertFTSEpisode } from './fts.js';
 
 /**
  * @param {import('better-sqlite3').Database} db
@@ -19,6 +20,7 @@ export async function encodeEpisode(db, embeddingProvider, {
   affect = {},
   arousalWeight = 0.3,
   private: isPrivate = false,
+  agent = 'default',
 }) {
   if (!content || typeof content !== 'string') throw new Error('content must be a non-empty string');
   if (salience < 0 || salience > 1) throw new Error('salience must be between 0 and 1');
@@ -38,8 +40,8 @@ export async function encodeEpisode(db, embeddingProvider, {
       INSERT INTO episodes (
         id, content, embedding, source, source_reliability, salience, context, affect,
         tags, causal_trigger, causal_consequence, created_at,
-        embedding_model, embedding_version, supersedes, "private"
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        embedding_model, embedding_version, supersedes, "private", agent
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
       id, content, embeddingBuffer, source, reliability, effectiveSalience,
       JSON.stringify(context),
@@ -49,6 +51,7 @@ export async function encodeEpisode(db, embeddingProvider, {
       now, embeddingProvider.modelName, embeddingProvider.modelVersion,
       supersedes || null,
       isPrivate ? 1 : 0,
+      agent,
     );
     db.prepare(
       'INSERT INTO vec_episodes(id, embedding, source, consolidated) VALUES (?, ?, ?, ?)'
@@ -56,6 +59,9 @@ export async function encodeEpisode(db, embeddingProvider, {
     if (supersedes) {
       db.prepare('UPDATE episodes SET superseded_by = ? WHERE id = ?').run(id, supersedes);
     }
+    if (hasFTSTables(db)) {
+      insertFTSEpisode(db, id, content, tags);
+    }
   });
 
   insertAndLink();