@happyvertical/smrt-core 0.30.0

package/dist/dispatch/types.d.ts

@@ -0,0 +1,149 @@
+import { DatabaseInterface } from '@happyvertical/sql';
+import { DispatchTenantScope } from './tenant-resolver.js';
+/**
+ * Dispatch message status
+ */
+export type DispatchStatus = 'pending' | 'processing' | 'completed' | 'failed';
+/**
+ * Options for emitting a dispatch
+ */
+export interface DispatchEmitOptions {
+    /** Source agent name */
+    source?: string;
+    /** Source agent instance ID */
+    sourceId?: string;
+    /** Correlation ID for linking request/response dispatch pairs */
+    correlationId?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Metadata passed to dispatch handlers
+ */
+export interface DispatchMetadata {
+    /** Dispatch ID */
+    id: string;
+    /** Signal type (e.g., 'campaign.completed') */
+    type: string;
+    /** Source agent name */
+    source: string;
+    /** Source agent instance ID */
+    sourceId: string;
+    /** Correlation ID for linking request/response dispatch pairs */
+    correlationId?: string;
+    /** Dispatch creation timestamp */
+    createdAt: Date;
+    /** Number of processing attempts */
+    attempts: number;
+    /** Additional metadata from emission */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Handler function for in-memory dispatch processing
+ */
+export type DispatchHandler = (payload: unknown, metadata: DispatchMetadata) => Promise<void>;
+/**
+ * Options for subscribing to dispatches
+ */
+export interface DispatchSubscribeOptions {
+    /** Signal type pattern (supports wildcards like 'campaign.*') */
+    signalType: string;
+    /** Subscriber name (usually agent name) */
+    subscriber: string;
+    /** Handler method name (default: 'handleDispatch') */
+    handler?: string;
+    /** Whether subscription is enabled */
+    enabled?: boolean;
+    /** Delivery mode: 'compete' (default, first-to-claim) or 'fanout' (each subscriber gets own copy) */
+    delivery?: 'compete' | 'fanout';
+}
+/**
+ * Options for processing dispatches
+ */
+export interface DispatchProcessOptions {
+    /** Maximum number of dispatches to process */
+    limit?: number;
+    /** Signal types to process (default: all subscribed) */
+    signalTypes?: string[];
+}
+/**
+ * Options for listing dispatches
+ */
+export interface DispatchListOptions {
+    /** Filter by status */
+    status?: DispatchStatus;
+    /** Filter by source agent */
+    source?: string;
+    /** Filter by signal type */
+    type?: string;
+    /** Filter by target subscriber */
+    targetSubscriber?: string;
+    /** Filter by correlation ID */
+    correlationId?: string;
+    /**
+     * Active tenant scope used to filter results (S5 #1398).
+     *
+     * Supplied by the DispatchBus from the server-derived tenant context — never
+     * from external/caller input, so visibility cannot be widened beyond the
+     * active scope. Semantics:
+     *
+     * - omitted / `enforced: false` → no tenant filter (pre-tenancy behavior).
+     * - `enforced: true`, `tenantId: T` → `(tenant_id = T OR tenant_id IS NULL)`.
+     * - `enforced: true`, `tenantId: null` → `tenant_id IS NULL` only (fail-closed
+     *   global scope when tenancy is on but no tenant context is active).
+     *
+     * @see {@link DispatchTenantScope}
+     */
+    tenantScope?: DispatchTenantScope;
+    /** Maximum results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Order by field */
+    orderBy?: string;
+}
+/**
+ * Options for retrying failed dispatches
+ */
+export interface DispatchRetryOptions {
+    /** Maximum total attempts before giving up */
+    maxAttempts?: number;
+    /** Only retry dispatches older than this date */
+    olderThan?: Date;
+    /** Only retry specific signal types */
+    signalTypes?: string[];
+}
+/**
+ * Options for cleaning up dispatches
+ */
+export interface DispatchCleanupOptions {
+    /** Delete completed dispatches older than this many days */
+    completedOlderThanDays?: number;
+    /** Delete failed dispatches older than this many days */
+    failedOlderThanDays?: number;
+}
+/**
+ * Result of dispatch cleanup
+ */
+export interface DispatchCleanupResult {
+    /** Number of completed dispatches deleted */
+    completedDeleted: number;
+    /** Number of failed dispatches deleted */
+    failedDeleted: number;
+}
+/**
+ * Options for creating a DispatchBus
+ */
+export interface DispatchBusOptions {
+    /** Database configuration or existing interface */
+    db?: DatabaseInterface | {
+        type: 'sqlite' | 'postgres' | 'json' | 'duckdb';
+        url: string;
+    };
+    /** Alias for db - persistence layer configuration */
+    persistence?: {
+        type: 'sql' | 'json' | 'duckdb';
+        url: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/dispatch/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dispatch/types.ts"],"names":[],"mappings":"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"}

package/dist/embeddings/hash.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Content Hashing for Embedding Change Detection
+ *
+ * Uses SHA-256 to detect when content has changed and embeddings need regeneration.
+ */
+/**
+ * Content hasher for embedding change detection
+ */
+export declare class ContentHasher {
+    /**
+     * Generate SHA-256 hash of content
+     *
+     * @param content - Text content to hash
+     * @returns Hex-encoded hash string
+     */
+    static hash(content: string): string;
+    /**
+     * Check if content has changed by comparing hashes
+     *
+     * @param content - Current content
+     * @param previousHash - Previously stored hash
+     * @returns True if content has changed
+     */
+    static hasChanged(content: string, previousHash: string): boolean;
+    /**
+     * Generate hash for multiple fields combined
+     *
+     * @param fields - Object with field names and values
+     * @returns Hex-encoded hash of combined content
+     */
+    static hashFields(fields: Record<string, string>): string;
+}
+//# sourceMappingURL=hash.d.ts.map

package/dist/embeddings/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/embeddings/hash.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;GAEG;AACH,qBAAa,aAAa;IACxB;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIpC;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAIjE;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;CAQ1D"}

package/dist/embeddings/hash.js

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+class ContentHasher {
+  /**
+   * Generate SHA-256 hash of content
+   *
+   * @param content - Text content to hash
+   * @returns Hex-encoded hash string
+   */
+  static hash(content) {
+    return createHash("sha256").update(content).digest("hex");
+  }
+  /**
+   * Check if content has changed by comparing hashes
+   *
+   * @param content - Current content
+   * @param previousHash - Previously stored hash
+   * @returns True if content has changed
+   */
+  static hasChanged(content, previousHash) {
+    return ContentHasher.hash(content) !== previousHash;
+  }
+  /**
+   * Generate hash for multiple fields combined
+   *
+   * @param fields - Object with field names and values
+   * @returns Hex-encoded hash of combined content
+   */
+  static hashFields(fields) {
+    const sortedKeys = Object.keys(fields).sort();
+    const combined = sortedKeys.map((key) => `${key}:${fields[key]}`).join("\n");
+    return ContentHasher.hash(combined);
+  }
+}
+export {
+  ContentHasher
+};
+//# sourceMappingURL=hash.js.map

package/dist/embeddings/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sources":["../../src/embeddings/hash.ts"],"sourcesContent":["/**\n * Content Hashing for Embedding Change Detection\n *\n * Uses SHA-256 to detect when content has changed and embeddings need regeneration.\n */\n\nimport { createHash } from 'node:crypto';\n\n/**\n * Content hasher for embedding change detection\n */\nexport class ContentHasher {\n  /**\n   * Generate SHA-256 hash of content\n   *\n   * @param content - Text content to hash\n   * @returns Hex-encoded hash string\n   */\n  static hash(content: string): string {\n    return createHash('sha256').update(content).digest('hex');\n  }\n\n  /**\n   * Check if content has changed by comparing hashes\n   *\n   * @param content - Current content\n   * @param previousHash - Previously stored hash\n   * @returns True if content has changed\n   */\n  static hasChanged(content: string, previousHash: string): boolean {\n    return ContentHasher.hash(content) !== previousHash;\n  }\n\n  /**\n   * Generate hash for multiple fields combined\n   *\n   * @param fields - Object with field names and values\n   * @returns Hex-encoded hash of combined content\n   */\n  static hashFields(fields: Record<string, string>): string {\n    // Sort keys for deterministic ordering\n    const sortedKeys = Object.keys(fields).sort();\n    const combined = sortedKeys\n      .map((key) => `${key}:${fields[key]}`)\n      .join('\\n');\n    return ContentHasher.hash(combined);\n  }\n}\n"],"names":[],"mappings":";AAWO,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOzB,OAAO,KAAK,SAAyB;AACnC,WAAO,WAAW,QAAQ,EAAE,OAAO,OAAO,EAAE,OAAO,KAAK;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,WAAW,SAAiB,cAA+B;AAChE,WAAO,cAAc,KAAK,OAAO,MAAM;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,WAAW,QAAwC;AAExD,UAAM,aAAa,OAAO,KAAK,MAAM,EAAE,KAAA;AACvC,UAAM,WAAW,WACd,IAAI,CAAC,QAAQ,GAAG,GAAG,IAAI,OAAO,GAAG,CAAC,EAAE,EACpC,KAAK,IAAI;AACZ,WAAO,cAAc,KAAK,QAAQ;AAAA,EACpC;AACF;"}

package/dist/embeddings/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * SMRT Embeddings Module
+ *
+ * Centralized embedding support for semantic search across SMRT objects.
+ *
+ * @example
+ * ```typescript
+ * import { EmbeddingProvider, EmbeddingStorage, CosineSimilarity } from './embeddings';
+ *
+ * // Create provider
+ * const provider = new EmbeddingProvider(config, ai);
+ *
+ * // Generate embeddings
+ * const embeddings = await provider.embed(['Hello world', 'Goodbye world']);
+ *
+ * // Store embeddings
+ * await EmbeddingStorage.upsert(db, {
+ *   objectClass: 'Article',
+ *   objectId: '123',
+ *   fieldName: 'title',
+ *   contentHash: ContentHasher.hash('Hello world'),
+ *   embedding: embeddings[0],
+ *   model: provider.getModelName(),
+ *   dimensions: provider.getDimensions()
+ * });
+ *
+ * // Search by similarity
+ * const results = CosineSimilarity.rankBySimilarity(queryEmbedding, candidates);
+ * ```
+ */
+export { ContentHasher } from './hash';
+export { DEFAULT_EMBEDDING_CONFIG, EmbeddingProvider } from './provider';
+export { CosineSimilarity } from './similarity';
+export { EmbeddingStorage } from './storage';
+export type { BatchGenerateOptions, BatchGenerateResult, BatchProgressCallback, ClassEmbeddingConfig, EmbeddingProviderType, FindSimilarOptions, GenerateEmbeddingsOptions, ProjectEmbeddingConfig, ResolvedEmbeddingConfig, SemanticSearchOptions, StoredEmbedding, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/embeddings/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/embeddings/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,YAAY,EACV,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,GAChB,MAAM,SAAS,CAAC"}

package/dist/embeddings/provider.d.ts

@@ -0,0 +1,75 @@
+import { EmbeddingProviderType, ProjectEmbeddingConfig } from './types';
+export type OptionalModuleImporter = (moduleName: string) => Promise<any>;
+export declare const LOCAL_TRANSFORMERS_PACKAGES: readonly ["@huggingface/transformers", "@xenova/transformers"];
+export type LocalTransformersPackage = (typeof LOCAL_TRANSFORMERS_PACKAGES)[number];
+export interface TransformersModuleResolution {
+    module: any;
+    packageName: LocalTransformersPackage;
+}
+export declare function resolveLocalTransformersModule(importModule?: OptionalModuleImporter): Promise<TransformersModuleResolution>;
+/**
+ * Embedding provider that supports both local and AI-based embedding generation.
+ *
+ * The "auto" provider prefers an already-configured AI embedding client.
+ * Local transformer models are still available via provider: "local", but should
+ * be an explicit choice for server workloads because model initialization can be
+ * CPU and memory intensive.
+ */
+export declare class EmbeddingProvider {
+    private localPipeline;
+    private localPipelineLoading;
+    private config;
+    private ai;
+    /**
+     * Create an embedding provider
+     *
+     * @param config - Project embedding configuration
+     * @param ai - Optional AI client for cloud embeddings (must have embed method)
+     */
+    constructor(config: ProjectEmbeddingConfig, ai?: unknown);
+    /**
+     * Generate embeddings for text(s)
+     *
+     * @param text - Single string or array of strings to embed
+     * @param providerOverride - Override the configured provider
+     * @returns Array of embedding vectors
+     */
+    embed(text: string | string[], providerOverride?: EmbeddingProviderType): Promise<number[][]>;
+    /**
+     * Generate embeddings using a local transformers model
+     */
+    private embedLocal;
+    /**
+     * Get or initialize the local embedding pipeline
+     */
+    private getLocalPipeline;
+    /**
+     * Initialize the local embedding pipeline
+     */
+    private initLocalPipeline;
+    /**
+     * Generate embeddings using AI API
+     */
+    private embedWithAI;
+    /**
+     * Get the model name being used
+     */
+    getModelName(): string;
+    /**
+     * Get the configured dimensions
+     */
+    getDimensions(): number;
+    /**
+     * Check if local embeddings are available
+     */
+    isLocalAvailable(): Promise<boolean>;
+    /**
+     * Check if AI embeddings are available
+     */
+    isAIAvailable(): boolean;
+}
+/**
+ * Default project embedding configuration
+ */
+export declare const DEFAULT_EMBEDDING_CONFIG: ProjectEmbeddingConfig;
+//# sourceMappingURL=provider.d.ts.map

package/dist/embeddings/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/embeddings/provider.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAY7E,MAAM,MAAM,sBAAsB,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAE1E,eAAO,MAAM,2BAA2B,gEAG9B,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,GAAG,CAAC;IACZ,WAAW,EAAE,wBAAwB,CAAC;CACvC;AAmBD,wBAAsB,8BAA8B,CAClD,YAAY,GAAE,sBAAuC,GACpD,OAAO,CAAC,4BAA4B,CAAC,CAavC;AAoBD;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,aAAa,CAA0C;IAC/D,OAAO,CAAC,oBAAoB,CACrB;IACP,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,EAAE,CAA4B;IAEtC;;;;;OAKG;gBACS,MAAM,EAAE,sBAAsB,EAAE,EAAE,CAAC,EAAE,OAAO;IAUxD;;;;;;OAMG;IACG,KAAK,CACT,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAuBtB;;OAEG;YACW,UAAU;IAMxB;;OAEG;YACW,gBAAgB;IAoB9B;;OAEG;YACW,iBAAiB;IAY/B;;OAEG;YACW,WAAW;IAiBzB;;OAEG;IACH,YAAY,IAAI,MAAM;IAUtB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC;IAS1C;;OAEG;IACH,aAAa,IAAI,OAAO;CAGzB;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,sBAKtC,CAAC"}

package/dist/embeddings/provider.js

@@ -0,0 +1,170 @@
+async function importOptional(moduleName) {
+  const name = moduleName;
+  return import(
+    /* @vite-ignore */
+    name
+  );
+}
+const LOCAL_TRANSFORMERS_PACKAGES = [
+  "@huggingface/transformers",
+  "@xenova/transformers"
+];
+function isModuleNotFoundError(error, moduleName) {
+  return error instanceof Error && (error.message.includes(`Cannot find module '${moduleName}'`) || error.message.includes(`Cannot find package '${moduleName}'`));
+}
+function formatTransformersResolutionError(attemptedPackages) {
+  return new Error(
+    `Local embeddings require one of: ${attemptedPackages.join(", ")}. Install one of them to use provider: "local", or switch to provider: "ai".`
+  );
+}
+async function resolveLocalTransformersModule(importModule = importOptional) {
+  for (const packageName of LOCAL_TRANSFORMERS_PACKAGES) {
+    try {
+      const module = await importModule(packageName);
+      return { module, packageName };
+    } catch (error) {
+      if (!isModuleNotFoundError(error, packageName)) {
+        throw error;
+      }
+    }
+  }
+  throw formatTransformersResolutionError(LOCAL_TRANSFORMERS_PACKAGES);
+}
+class EmbeddingProvider {
+  localPipeline = null;
+  localPipelineLoading = null;
+  config;
+  ai;
+  /**
+   * Create an embedding provider
+   *
+   * @param config - Project embedding configuration
+   * @param ai - Optional AI client for cloud embeddings (must have embed method)
+   */
+  constructor(config, ai) {
+    this.config = config;
+    if (ai && typeof ai.embed === "function") {
+      this.ai = ai;
+    } else {
+      this.ai = null;
+    }
+  }
+  /**
+   * Generate embeddings for text(s)
+   *
+   * @param text - Single string or array of strings to embed
+   * @param providerOverride - Override the configured provider
+   * @returns Array of embedding vectors
+   */
+  async embed(text, providerOverride) {
+    const provider = providerOverride || this.config.provider;
+    const texts = Array.isArray(text) ? text : [text];
+    if (provider === "local") {
+      return this.embedLocal(texts);
+    }
+    if (provider === "ai") {
+      return this.embedWithAI(texts);
+    }
+    if (this.ai) {
+      return this.embedWithAI(texts);
+    }
+    return this.embedLocal(texts);
+  }
+  /**
+   * Generate embeddings using a local transformers model
+   */
+  async embedLocal(texts) {
+    const pipeline = await this.getLocalPipeline();
+    const results = await pipeline(texts, { pooling: "mean", normalize: true });
+    return results.tolist();
+  }
+  /**
+   * Get or initialize the local embedding pipeline
+   */
+  async getLocalPipeline() {
+    if (this.localPipeline) {
+      return this.localPipeline;
+    }
+    if (this.localPipelineLoading) {
+      return this.localPipelineLoading;
+    }
+    this.localPipelineLoading = this.initLocalPipeline();
+    try {
+      this.localPipeline = await this.localPipelineLoading;
+      return this.localPipeline;
+    } finally {
+      this.localPipelineLoading = null;
+    }
+  }
+  /**
+   * Initialize the local embedding pipeline
+   */
+  async initLocalPipeline() {
+    const { module: transformers } = await resolveLocalTransformersModule();
+    const { pipeline } = transformers;
+    const model = this.config.localModel || "Xenova/bge-base-en-v1.5";
+    const pipe = await pipeline("feature-extraction", model);
+    return pipe;
+  }
+  /**
+   * Generate embeddings using AI API
+   */
+  async embedWithAI(texts) {
+    if (!this.ai) {
+      throw new Error(
+        'AI client not available for embeddings. Either configure an AI client or use provider: "local".'
+      );
+    }
+    const model = this.config.aiModel || "text-embedding-3-small";
+    const response = await this.ai.embed(texts, {
+      model,
+      dimensions: this.config.dimensions
+    });
+    return response.embeddings;
+  }
+  /**
+   * Get the model name being used
+   */
+  getModelName() {
+    if (this.config.provider === "ai" || this.config.provider === "auto" && this.ai) {
+      return this.config.aiModel || "text-embedding-3-small";
+    }
+    return this.config.localModel || "Xenova/bge-base-en-v1.5";
+  }
+  /**
+   * Get the configured dimensions
+   */
+  getDimensions() {
+    return this.config.dimensions;
+  }
+  /**
+   * Check if local embeddings are available
+   */
+  async isLocalAvailable() {
+    try {
+      await resolveLocalTransformersModule();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if AI embeddings are available
+   */
+  isAIAvailable() {
+    return this.ai !== null;
+  }
+}
+const DEFAULT_EMBEDDING_CONFIG = {
+  dimensions: 768,
+  provider: "local",
+  localModel: "Xenova/bge-base-en-v1.5",
+  aiModel: "text-embedding-3-small"
+};
+export {
+  DEFAULT_EMBEDDING_CONFIG,
+  EmbeddingProvider,
+  LOCAL_TRANSFORMERS_PACKAGES,
+  resolveLocalTransformersModule
+};
+//# sourceMappingURL=provider.js.map

package/dist/embeddings/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sources":["../../src/embeddings/provider.ts"],"sourcesContent":["/**\n * Embedding Provider\n *\n * Unified interface for generating embeddings using local models or AI APIs.\n * Supports transformers.js packages for local inference and @happyvertical/ai\n * for cloud embeddings.\n */\n\nimport type { EmbeddingProviderType, ProjectEmbeddingConfig } from './types';\n\n/**\n * Dynamically import an optional dependency.\n * Uses a variable to prevent TypeScript from statically analyzing the import.\n */\nasync function importOptional(moduleName: string): Promise<any> {\n  // Using a variable prevents TypeScript from trying to resolve the module at compile time\n  const name = moduleName;\n  return import(/* @vite-ignore */ name);\n}\n\nexport type OptionalModuleImporter = (moduleName: string) => Promise<any>;\n\nexport const LOCAL_TRANSFORMERS_PACKAGES = [\n  '@huggingface/transformers',\n  '@xenova/transformers',\n] as const;\n\nexport type LocalTransformersPackage =\n  (typeof LOCAL_TRANSFORMERS_PACKAGES)[number];\n\nexport interface TransformersModuleResolution {\n  module: any;\n  packageName: LocalTransformersPackage;\n}\n\nfunction isModuleNotFoundError(error: unknown, moduleName: string): boolean {\n  return (\n    error instanceof Error &&\n    (error.message.includes(`Cannot find module '${moduleName}'`) ||\n      error.message.includes(`Cannot find package '${moduleName}'`))\n  );\n}\n\nfunction formatTransformersResolutionError(\n  attemptedPackages: readonly string[],\n): Error {\n  return new Error(\n    `Local embeddings require one of: ${attemptedPackages.join(', ')}. ` +\n      `Install one of them to use provider: \"local\", or switch to provider: \"ai\".`,\n  );\n}\n\nexport async function resolveLocalTransformersModule(\n  importModule: OptionalModuleImporter = importOptional,\n): Promise<TransformersModuleResolution> {\n  for (const packageName of LOCAL_TRANSFORMERS_PACKAGES) {\n    try {\n      const module = await importModule(packageName);\n      return { module, packageName };\n    } catch (error) {\n      if (!isModuleNotFoundError(error, packageName)) {\n        throw error;\n      }\n    }\n  }\n\n  throw formatTransformersResolutionError(LOCAL_TRANSFORMERS_PACKAGES);\n}\n\n/**\n * Interface for AI client that can generate embeddings\n */\ninterface EmbeddingCapableAI {\n  embed(\n    text: string | string[],\n    options?: { model?: string; dimensions?: number },\n  ): Promise<{ embeddings: number[][] }>;\n}\n\n/**\n * Pipeline type for local transformers packages\n */\ntype FeatureExtractionPipeline = (\n  texts: string[],\n  options?: { pooling?: string; normalize?: boolean },\n) => Promise<{ tolist: () => number[][] }>;\n\n/**\n * Embedding provider that supports both local and AI-based embedding generation.\n *\n * The \"auto\" provider prefers an already-configured AI embedding client.\n * Local transformer models are still available via provider: \"local\", but should\n * be an explicit choice for server workloads because model initialization can be\n * CPU and memory intensive.\n */\nexport class EmbeddingProvider {\n  private localPipeline: FeatureExtractionPipeline | null = null;\n  private localPipelineLoading: Promise<FeatureExtractionPipeline> | null =\n    null;\n  private config: ProjectEmbeddingConfig;\n  private ai: EmbeddingCapableAI | null;\n\n  /**\n   * Create an embedding provider\n   *\n   * @param config - Project embedding configuration\n   * @param ai - Optional AI client for cloud embeddings (must have embed method)\n   */\n  constructor(config: ProjectEmbeddingConfig, ai?: unknown) {\n    this.config = config;\n    // Cast to EmbeddingCapableAI if it has an embed method\n    if (ai && typeof (ai as any).embed === 'function') {\n      this.ai = ai as EmbeddingCapableAI;\n    } else {\n      this.ai = null;\n    }\n  }\n\n  /**\n   * Generate embeddings for text(s)\n   *\n   * @param text - Single string or array of strings to embed\n   * @param providerOverride - Override the configured provider\n   * @returns Array of embedding vectors\n   */\n  async embed(\n    text: string | string[],\n    providerOverride?: EmbeddingProviderType,\n  ): Promise<number[][]> {\n    const provider = providerOverride || this.config.provider;\n    const texts = Array.isArray(text) ? text : [text];\n\n    if (provider === 'local') {\n      return this.embedLocal(texts);\n    }\n\n    if (provider === 'ai') {\n      return this.embedWithAI(texts);\n    }\n\n    // 'auto' - use the configured AI client when present. This avoids\n    // unexpectedly loading a large local transformer model inside app workers.\n    // Local embeddings remain the explicit no-AI fallback for callers that\n    // invoke embedding generation without an AI client.\n    if (this.ai) {\n      return this.embedWithAI(texts);\n    }\n\n    return this.embedLocal(texts);\n  }\n\n  /**\n   * Generate embeddings using a local transformers model\n   */\n  private async embedLocal(texts: string[]): Promise<number[][]> {\n    const pipeline = await this.getLocalPipeline();\n    const results = await pipeline(texts, { pooling: 'mean', normalize: true });\n    return results.tolist();\n  }\n\n  /**\n   * Get or initialize the local embedding pipeline\n   */\n  private async getLocalPipeline(): Promise<FeatureExtractionPipeline> {\n    if (this.localPipeline) {\n      return this.localPipeline;\n    }\n\n    // Prevent multiple concurrent initializations\n    if (this.localPipelineLoading) {\n      return this.localPipelineLoading;\n    }\n\n    this.localPipelineLoading = this.initLocalPipeline();\n\n    try {\n      this.localPipeline = await this.localPipelineLoading;\n      return this.localPipeline;\n    } finally {\n      this.localPipelineLoading = null;\n    }\n  }\n\n  /**\n   * Initialize the local embedding pipeline\n   */\n  private async initLocalPipeline(): Promise<FeatureExtractionPipeline> {\n    const { module: transformers } = await resolveLocalTransformersModule();\n    const { pipeline } = transformers;\n\n    const model = this.config.localModel || 'Xenova/bge-base-en-v1.5';\n\n    // Initialize the feature extraction pipeline\n    const pipe = await pipeline('feature-extraction', model);\n\n    return pipe as unknown as FeatureExtractionPipeline;\n  }\n\n  /**\n   * Generate embeddings using AI API\n   */\n  private async embedWithAI(texts: string[]): Promise<number[][]> {\n    if (!this.ai) {\n      throw new Error(\n        'AI client not available for embeddings. ' +\n          'Either configure an AI client or use provider: \"local\".',\n      );\n    }\n\n    const model = this.config.aiModel || 'text-embedding-3-small';\n    const response = await this.ai.embed(texts, {\n      model,\n      dimensions: this.config.dimensions,\n    });\n\n    return response.embeddings;\n  }\n\n  /**\n   * Get the model name being used\n   */\n  getModelName(): string {\n    if (\n      this.config.provider === 'ai' ||\n      (this.config.provider === 'auto' && this.ai)\n    ) {\n      return this.config.aiModel || 'text-embedding-3-small';\n    }\n    return this.config.localModel || 'Xenova/bge-base-en-v1.5';\n  }\n\n  /**\n   * Get the configured dimensions\n   */\n  getDimensions(): number {\n    return this.config.dimensions;\n  }\n\n  /**\n   * Check if local embeddings are available\n   */\n  async isLocalAvailable(): Promise<boolean> {\n    try {\n      await resolveLocalTransformersModule();\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Check if AI embeddings are available\n   */\n  isAIAvailable(): boolean {\n    return this.ai !== null;\n  }\n}\n\n/**\n * Default project embedding configuration\n */\nexport const DEFAULT_EMBEDDING_CONFIG: ProjectEmbeddingConfig = {\n  dimensions: 768,\n  provider: 'local',\n  localModel: 'Xenova/bge-base-en-v1.5',\n  aiModel: 'text-embedding-3-small',\n};\n"],"names":[],"mappings":"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"}

package/dist/embeddings/similarity.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Vector Similarity Calculations
+ *
+ * Provides cosine similarity for semantic search.
+ */
+/**
+ * Cosine similarity calculator for embedding vectors
+ */
+export declare class CosineSimilarity {
+    /**
+     * Calculate cosine similarity between two vectors
+     *
+     * @param a - First embedding vector
+     * @param b - Second embedding vector
+     * @returns Similarity score between -1 and 1 (higher = more similar)
+     * @throws Error if vectors have different dimensions
+     */
+    static calculate(a: number[], b: number[]): number;
+    /**
+     * Calculate similarities between a query vector and multiple candidates
+     *
+     * @param query - Query embedding vector
+     * @param candidates - Array of candidate vectors with IDs
+     * @returns Array sorted by similarity (highest first)
+     */
+    static rankBySimilarity<T extends {
+        id: string;
+        embedding: number[];
+    }>(query: number[], candidates: T[]): Array<T & {
+        similarity: number;
+    }>;
+    /**
+     * Filter candidates by minimum similarity threshold
+     *
+     * @param query - Query embedding vector
+     * @param candidates - Array of candidate vectors
+     * @param minSimilarity - Minimum similarity threshold (0-1)
+     * @returns Filtered and sorted results
+     */
+    static filterBySimilarity<T extends {
+        id: string;
+        embedding: number[];
+    }>(query: number[], candidates: T[], minSimilarity: number): Array<T & {
+        similarity: number;
+    }>;
+}
+//# sourceMappingURL=similarity.d.ts.map

package/dist/embeddings/similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.d.ts","sourceRoot":"","sources":["../../src/embeddings/similarity.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;OAOG;IACH,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IA+BlD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,EACnE,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,CAAC,EAAE,GACd,KAAK,CAAC,CAAC,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IASpC;;;;;;;OAOG;IACH,MAAM,CAAC,kBAAkB,CAAC,CAAC,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,EACrE,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,CAAC,EAAE,EACf,aAAa,EAAE,MAAM,GACpB,KAAK,CAAC,CAAC,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CAKrC"}

package/dist/embeddings/similarity.js

@@ -0,0 +1,64 @@
+class CosineSimilarity {
+  /**
+   * Calculate cosine similarity between two vectors
+   *
+   * @param a - First embedding vector
+   * @param b - Second embedding vector
+   * @returns Similarity score between -1 and 1 (higher = more similar)
+   * @throws Error if vectors have different dimensions
+   */
+  static calculate(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(
+        `Vector dimension mismatch: ${a.length} vs ${b.length}. Ensure all embeddings use the same model and dimensions.`
+      );
+    }
+    if (a.length === 0) {
+      return 0;
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0) {
+      return 0;
+    }
+    return dotProduct / denominator;
+  }
+  /**
+   * Calculate similarities between a query vector and multiple candidates
+   *
+   * @param query - Query embedding vector
+   * @param candidates - Array of candidate vectors with IDs
+   * @returns Array sorted by similarity (highest first)
+   */
+  static rankBySimilarity(query, candidates) {
+    const results = candidates.map((candidate) => ({
+      ...candidate,
+      similarity: CosineSimilarity.calculate(query, candidate.embedding)
+    }));
+    return results.sort((a, b) => b.similarity - a.similarity);
+  }
+  /**
+   * Filter candidates by minimum similarity threshold
+   *
+   * @param query - Query embedding vector
+   * @param candidates - Array of candidate vectors
+   * @param minSimilarity - Minimum similarity threshold (0-1)
+   * @returns Filtered and sorted results
+   */
+  static filterBySimilarity(query, candidates, minSimilarity) {
+    return CosineSimilarity.rankBySimilarity(query, candidates).filter(
+      (result) => result.similarity >= minSimilarity
+    );
+  }
+}
+export {
+  CosineSimilarity
+};
+//# sourceMappingURL=similarity.js.map