sis-tools 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1531 @@
+'use strict';
+
+// src/types.ts
+function toSchema(tool) {
+  const required = Object.entries(tool.parameters).filter(([, v]) => v.required !== false).map(([k]) => k);
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: {
+      type: "object",
+      properties: tool.parameters,
+      required
+    }
+  };
+}
+function toOpenAISchema(tool) {
+  return {
+    type: "function",
+    function: toSchema(tool)
+  };
+}
+function toAnthropicSchema(tool) {
+  const schema = toSchema(tool);
+  return {
+    name: schema.name,
+    description: schema.description,
+    input_schema: schema.parameters
+  };
+}
+
+// src/embeddings/base.ts
+function buildToolText(name, description, semanticHints, examples) {
+  const parts = [`${name}: ${description}`];
+  if (semanticHints?.length) {
+    parts.push(`Related: ${semanticHints.join(", ")}`);
+  }
+  if (examples?.length) {
+    const queries = examples.map((ex) => ex.query).filter(Boolean);
+    if (queries.length) {
+      parts.push(`Examples: ${queries.join("; ")}`);
+    }
+  }
+  return parts.join(" | ");
+}
+
+// src/embeddings/openai.ts
+var DEFAULT_DIMENSIONS = {
+  "text-embedding-3-small": 1536,
+  "text-embedding-3-large": 3072,
+  "text-embedding-ada-002": 1536
+};
+var OpenAIEmbeddings = class {
+  client = null;
+  model;
+  apiKey;
+  dimensions;
+  constructor(options = {}) {
+    const { model = "text-embedding-3-small", apiKey, dimensions } = options;
+    this.model = model;
+    this.apiKey = apiKey;
+    this.dimensions = dimensions ?? DEFAULT_DIMENSIONS[model] ?? 1536;
+  }
+  async ensureClient() {
+    if (this.client) {
+      return this.client;
+    }
+    try {
+      const mod = await import('openai');
+      const OpenAI = mod?.OpenAI ?? mod?.default?.OpenAI ?? mod?.default;
+      if (!OpenAI) {
+        throw new Error("OpenAI export not found");
+      }
+      this.client = new OpenAI({ apiKey: this.apiKey });
+      return this.client;
+    } catch {
+      throw new Error(
+        "OpenAI provider requires the openai package. Install with: npm install openai"
+      );
+    }
+  }
+  async embed(text) {
+    const client = await this.ensureClient();
+    const params = {
+      model: this.model,
+      input: text
+    };
+    if (this.model.includes("text-embedding-3")) {
+      params.dimensions = this.dimensions;
+    }
+    const response = await client.embeddings.create(params);
+    return response.data[0].embedding;
+  }
+  async embedBatch(texts) {
+    const client = await this.ensureClient();
+    const params = {
+      model: this.model,
+      input: texts
+    };
+    if (this.model.includes("text-embedding-3")) {
+      params.dimensions = this.dimensions;
+    }
+    const response = await client.embeddings.create(params);
+    const sorted = [...response.data].sort(
+      (a, b) => a.index - b.index
+    );
+    return sorted.map((item) => item.embedding);
+  }
+};
+
+// src/embeddings/cohere.ts
+var DEFAULT_DIMENSIONS2 = {
+  "embed-english-v3.0": 1024,
+  "embed-multilingual-v3.0": 1024,
+  "embed-english-light-v3.0": 384,
+  "embed-multilingual-light-v3.0": 384
+};
+var CohereEmbeddings = class {
+  client = null;
+  model;
+  inputType;
+  apiKey;
+  dimensions;
+  constructor(options = {}) {
+    const {
+      model = "embed-english-v3.0",
+      apiKey,
+      inputType = "search_query"
+    } = options;
+    this.model = model;
+    this.inputType = inputType;
+    this.apiKey = apiKey;
+    this.dimensions = DEFAULT_DIMENSIONS2[model] ?? 1024;
+  }
+  async ensureClient() {
+    if (this.client) {
+      return this.client;
+    }
+    try {
+      const mod = await import('cohere-ai');
+      const CohereClient = mod?.CohereClient ?? mod?.default?.CohereClient ?? mod?.default;
+      if (!CohereClient) {
+        throw new Error("CohereClient export not found");
+      }
+      this.client = new CohereClient({ token: this.apiKey });
+      return this.client;
+    } catch {
+      throw new Error(
+        "Cohere provider requires the cohere-ai package. Install with: npm install cohere-ai"
+      );
+    }
+  }
+  async embed(text) {
+    const client = await this.ensureClient();
+    const response = await client.embed({
+      texts: [text],
+      model: this.model,
+      inputType: this.inputType
+    });
+    return response.embeddings[0];
+  }
+  async embedBatch(texts) {
+    const client = await this.ensureClient();
+    const response = await client.embed({
+      texts,
+      model: this.model,
+      inputType: this.inputType
+    });
+    return response.embeddings;
+  }
+};
+
+// src/embeddings/google.ts
+var DEFAULT_DIMENSIONS3 = {
+  "text-embedding-004": 768,
+  "text-embedding-preview-0815": 768
+};
+var GoogleEmbeddings = class {
+  client = null;
+  model;
+  apiKey;
+  dimensions;
+  constructor(options = {}) {
+    const { model = "text-embedding-004", apiKey } = options;
+    this.model = model;
+    this.apiKey = apiKey;
+    this.dimensions = DEFAULT_DIMENSIONS3[model] ?? 768;
+  }
+  async ensureClient() {
+    if (this.client) {
+      return this.client;
+    }
+    try {
+      const mod = await import('@google/generative-ai');
+      const GoogleGenerativeAI = mod?.GoogleGenerativeAI ?? mod?.default?.GoogleGenerativeAI ?? mod?.default;
+      if (!GoogleGenerativeAI) {
+        throw new Error("GoogleGenerativeAI export not found");
+      }
+      this.client = new GoogleGenerativeAI(this.apiKey || process.env.GOOGLE_API_KEY);
+      return this.client;
+    } catch {
+      throw new Error(
+        "Google provider requires @google/generative-ai. Install with: npm install @google/generative-ai"
+      );
+    }
+  }
+  async embed(text) {
+    const client = await this.ensureClient();
+    const model = client.getGenerativeModel({ model: this.model });
+    const result = await model.embedContent(text);
+    return result.embedding.values;
+  }
+  async embedBatch(texts) {
+    const client = await this.ensureClient();
+    const model = client.getGenerativeModel({ model: this.model });
+    const results = await Promise.all(
+      texts.map((text) => model.embedContent(text))
+    );
+    return results.map((r) => r.embedding.values);
+  }
+};
+
+// src/embeddings/index.ts
+function getProvider(name, options = {}) {
+  switch (name) {
+    case "openai":
+      return new OpenAIEmbeddings(options);
+    case "cohere":
+      return new CohereEmbeddings(options);
+    case "google":
+      return new GoogleEmbeddings(options);
+    default:
+      throw new Error(
+        `Unknown provider: ${name}. Available: openai, cohere, google`
+      );
+  }
+}
+
+// src/scoring.ts
+var CosineSimilarity = class {
+  compute(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions must match: ${a.length} !== ${b.length}`);
+    }
+    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];
+    }
+    normA = Math.sqrt(normA);
+    normB = Math.sqrt(normB);
+    if (normA === 0 || normB === 0) {
+      return 0;
+    }
+    return dotProduct / (normA * normB);
+  }
+};
+var EuclideanSimilarity = class {
+  compute(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions must match: ${a.length} !== ${b.length}`);
+    }
+    let sumSquares = 0;
+    for (let i = 0; i < a.length; i++) {
+      const diff = a[i] - b[i];
+      sumSquares += diff * diff;
+    }
+    const distance = Math.sqrt(sumSquares);
+    return 1 / (1 + distance);
+  }
+};
+var DotProductSimilarity = class {
+  compute(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions must match: ${a.length} !== ${b.length}`);
+    }
+    let dotProduct = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+    }
+    return dotProduct;
+  }
+};
+var PriorityScoring = class {
+  maxScore;
+  constructor(maxScore = 1) {
+    this.maxScore = maxScore;
+  }
+  score(similarity, tool) {
+    const priority = tool.metadata.priority ?? 1;
+    const boosted = similarity * priority;
+    return Math.min(boosted, this.maxScore);
+  }
+};
+var WeightedScoring = class {
+  similarityWeight;
+  priorityWeight;
+  maxScore;
+  constructor(similarityWeight = 0.8, priorityWeight = 0.2, maxScore = 1) {
+    this.similarityWeight = similarityWeight;
+    this.priorityWeight = priorityWeight;
+    this.maxScore = maxScore;
+  }
+  score(similarity, tool) {
+    const priority = tool.metadata.priority ?? 1;
+    const normalizedPriority = Math.min(priority / 2, 1);
+    const weighted = this.similarityWeight * similarity + this.priorityWeight * normalizedPriority;
+    return Math.min(weighted, this.maxScore);
+  }
+};
+var TagBoostScoring = class {
+  boostTags;
+  boostFactor;
+  maxScore;
+  constructor(boostTags = [], boostFactor = 1.5, maxScore = 1) {
+    this.boostTags = new Set(boostTags);
+    this.boostFactor = boostFactor;
+    this.maxScore = maxScore;
+  }
+  score(similarity, tool) {
+    const toolTags = new Set(tool.metadata.tags ?? []);
+    const hasMatchingTag = [...toolTags].some((tag) => this.boostTags.has(tag));
+    const boosted = hasMatchingTag ? similarity * this.boostFactor : similarity;
+    return Math.min(boosted, this.maxScore);
+  }
+};
+var CompositeScoring = class {
+  scorers;
+  constructor(scorers) {
+    this.scorers = scorers;
+  }
+  score(similarity, tool) {
+    let currentScore = similarity;
+    for (const scorer of this.scorers) {
+      currentScore = scorer.score(currentScore, tool);
+    }
+    return currentScore;
+  }
+};
+var DEFAULT_SIMILARITY = new CosineSimilarity();
+var DEFAULT_SCORING = new PriorityScoring();
+
+// src/store.ts
+var VectorStore = class {
+  tools = [];
+  embeddings = [];
+  /**
+   * Add a tool with its embedding to the store
+   */
+  add(tool, embedding) {
+    tool.embedding = embedding;
+    this.tools.push(tool);
+    this.embeddings.push(embedding);
+  }
+  /**
+   * Add multiple tools with embeddings
+   */
+  addBatch(tools, embeddings) {
+    for (let i = 0; i < tools.length; i++) {
+      this.add(tools[i], embeddings[i]);
+    }
+  }
+  /**
+   * Search for similar tools
+   *
+   * @param queryEmbedding - The query embedding vector
+   * @param topK - Maximum number of results
+   * @param threshold - Minimum score to include
+   * @param similarityFn - Custom similarity function (defaults to cosine)
+   * @param scoringFn - Custom scoring function (defaults to priority scoring)
+   */
+  search(queryEmbedding, topK = 5, threshold = 0, similarityFn, scoringFn) {
+    if (this.tools.length === 0) {
+      return [];
+    }
+    const simFn = similarityFn ?? DEFAULT_SIMILARITY;
+    const scoreFn = scoringFn ?? DEFAULT_SCORING;
+    const matches = [];
+    for (let i = 0; i < this.tools.length; i++) {
+      const tool = this.tools[i];
+      const embedding = this.embeddings[i];
+      const similarity = simFn.compute(queryEmbedding, embedding);
+      const finalScore = scoreFn.score(similarity, tool);
+      if (finalScore >= threshold) {
+        matches.push({ tool, score: finalScore });
+      }
+    }
+    matches.sort((a, b) => b.score - a.score);
+    return matches.slice(0, topK);
+  }
+  /**
+   * Remove a tool by name
+   */
+  remove(toolName) {
+    const index = this.tools.findIndex((t) => t.name === toolName);
+    if (index !== -1) {
+      this.tools.splice(index, 1);
+      this.embeddings.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Remove all tools from the store
+   */
+  clear() {
+    this.tools = [];
+    this.embeddings = [];
+  }
+  /**
+   * Get a tool by name
+   */
+  get(toolName) {
+    return this.tools.find((t) => t.name === toolName);
+  }
+  /**
+   * Number of tools in the store
+   */
+  get size() {
+    return this.tools.length;
+  }
+  /**
+   * Check if a tool exists by name
+   */
+  has(toolName) {
+    return this.tools.some((t) => t.name === toolName);
+  }
+  /**
+   * Get all tools
+   */
+  getAll() {
+    return [...this.tools];
+  }
+};
+
+// src/formatters.ts
+var RawFormatter = class {
+  name = "raw";
+  format(tool) {
+    return tool.schema;
+  }
+};
+var OpenAIFormatter = class {
+  name = "openai";
+  format(tool) {
+    return {
+      type: "function",
+      function: tool.schema
+    };
+  }
+};
+var AnthropicFormatter = class {
+  name = "anthropic";
+  format(tool) {
+    return {
+      name: tool.schema.name,
+      description: tool.schema.description,
+      input_schema: tool.schema.parameters
+    };
+  }
+};
+var GeminiFormatter = class {
+  name = "gemini";
+  format(tool) {
+    return {
+      name: tool.schema.name,
+      description: tool.schema.description,
+      parameters: tool.schema.parameters
+    };
+  }
+};
+var MistralFormatter = class {
+  name = "mistral";
+  format(tool) {
+    return {
+      type: "function",
+      function: {
+        name: tool.schema.name,
+        description: tool.schema.description,
+        parameters: tool.schema.parameters
+      }
+    };
+  }
+};
+var LlamaFormatter = class {
+  name = "llama";
+  format(tool) {
+    return {
+      type: "function",
+      function: {
+        name: tool.schema.name,
+        description: tool.schema.description,
+        parameters: tool.schema.parameters
+      }
+    };
+  }
+};
+var CohereFormatter = class {
+  name = "cohere";
+  format(tool) {
+    const params = tool.schema.parameters;
+    const properties = params.properties;
+    const required = new Set(params.required);
+    const parameterDefinitions = {};
+    for (const [name, prop] of Object.entries(properties)) {
+      parameterDefinitions[name] = {
+        type: prop.type ?? "string",
+        description: prop.description ?? "",
+        required: required.has(name)
+      };
+    }
+    return {
+      name: tool.schema.name,
+      description: tool.schema.description,
+      parameter_definitions: parameterDefinitions
+    };
+  }
+};
+var MinimalFormatter = class {
+  name = "minimal";
+  format(tool) {
+    return {
+      name: tool.schema.name,
+      description: tool.schema.description
+    };
+  }
+};
+var VerboseFormatter = class {
+  name = "verbose";
+  format(tool) {
+    return {
+      name: tool.name,
+      schema: tool.schema,
+      score: tool.score,
+      hasHandler: tool.handler !== void 0
+    };
+  }
+};
+var formatters = /* @__PURE__ */ new Map();
+function registerFormatter(formatter) {
+  formatters.set(formatter.name, formatter);
+}
+function unregisterFormatter(name) {
+  return formatters.delete(name);
+}
+function getFormatter(name) {
+  const formatter = formatters.get(name);
+  if (!formatter) {
+    const available = Array.from(formatters.keys()).join(", ");
+    throw new Error(`Unknown formatter '${name}'. Available: ${available}`);
+  }
+  return formatter;
+}
+function listFormatters() {
+  return Array.from(formatters.keys());
+}
+function hasFormatter(name) {
+  return formatters.has(name);
+}
+function formatTools(tools, formatter) {
+  const fmt = typeof formatter === "string" ? getFormatter(formatter) : formatter;
+  if (fmt.formatBatch) {
+    return fmt.formatBatch(tools);
+  }
+  return tools.map((tool) => fmt.format(tool));
+}
+function registerDefaults() {
+  const defaults = [
+    new RawFormatter(),
+    new OpenAIFormatter(),
+    new AnthropicFormatter(),
+    new GeminiFormatter(),
+    new MistralFormatter(),
+    new LlamaFormatter(),
+    new CohereFormatter(),
+    new MinimalFormatter(),
+    new VerboseFormatter()
+  ];
+  for (const formatter of defaults) {
+    registerFormatter(formatter);
+  }
+}
+registerDefaults();
+
+// src/hooks.ts
+var HookType = /* @__PURE__ */ ((HookType2) => {
+  HookType2["PRE_REGISTER"] = "pre_register";
+  HookType2["POST_REGISTER"] = "post_register";
+  HookType2["PRE_EMBED"] = "pre_embed";
+  HookType2["POST_EMBED"] = "post_embed";
+  HookType2["PRE_RESOLVE"] = "pre_resolve";
+  HookType2["POST_RESOLVE"] = "post_resolve";
+  HookType2["PRE_SEARCH"] = "pre_search";
+  HookType2["POST_SEARCH"] = "post_search";
+  HookType2["PRE_EXECUTE"] = "pre_execute";
+  HookType2["POST_EXECUTE"] = "post_execute";
+  return HookType2;
+})(HookType || {});
+function createContext(hookType, data = {}) {
+  return {
+    hookType,
+    data,
+    cancelled: false,
+    error: null
+  };
+}
+function cancelContext(context, reason) {
+  context.cancelled = true;
+  if (reason) {
+    context.data.cancelReason = reason;
+  }
+}
+function setContextError(context, error) {
+  context.error = error;
+  context.cancelled = true;
+}
+function createHook(hookType, fn, priority = 0) {
+  return {
+    hookType,
+    priority,
+    execute: fn
+  };
+}
+var HookRegistry = class {
+  hooks = /* @__PURE__ */ new Map();
+  constructor() {
+    for (const type of Object.values(HookType)) {
+      this.hooks.set(type, []);
+    }
+  }
+  /**
+   * Register a hook
+   */
+  register(hook) {
+    const hooks = this.hooks.get(hook.hookType) ?? [];
+    hooks.push(hook);
+    hooks.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    this.hooks.set(hook.hookType, hooks);
+  }
+  /**
+   * Register a function as a hook
+   */
+  on(hookType, fn, priority = 0) {
+    const hook = createHook(hookType, fn, priority);
+    this.register(hook);
+    return hook;
+  }
+  /**
+   * Unregister a hook
+   */
+  unregister(hook) {
+    const hooks = this.hooks.get(hook.hookType) ?? [];
+    const index = hooks.indexOf(hook);
+    if (index !== -1) {
+      hooks.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Clear hooks
+   */
+  clear(hookType) {
+    if (hookType) {
+      this.hooks.set(hookType, []);
+    } else {
+      for (const type of Object.values(HookType)) {
+        this.hooks.set(type, []);
+      }
+    }
+  }
+  /**
+   * Get all hooks for a type
+   */
+  getHooks(hookType) {
+    return [...this.hooks.get(hookType) ?? []];
+  }
+  /**
+   * Check if any hooks are registered for a type
+   */
+  hasHooks(hookType) {
+    return (this.hooks.get(hookType) ?? []).length > 0;
+  }
+  /**
+   * Run all hooks of a given type
+   */
+  async run(hookType, context) {
+    const hooks = this.hooks.get(hookType) ?? [];
+    for (const hook of hooks) {
+      if (context.cancelled) {
+        break;
+      }
+      try {
+        const result = hook.execute(context);
+        if (result instanceof Promise) {
+          context = await result;
+        } else {
+          context = result;
+        }
+      } catch (error) {
+        setContextError(context, error);
+        break;
+      }
+    }
+    return context;
+  }
+};
+var LoggingHook = class {
+  hookType;
+  priority = 0;
+  logger;
+  constructor(hookType, logger) {
+    this.hookType = hookType;
+    this.logger = logger ?? console.log;
+  }
+  execute(context) {
+    this.logger(`[${this.hookType}] data=${JSON.stringify(context.data)}`);
+    return context;
+  }
+};
+var TimingHook = class {
+  hookType;
+  priority = 0;
+  preHook;
+  postHook;
+  timingKey;
+  constructor(preHook, postHook, timingKey = "timing") {
+    this.preHook = preHook;
+    this.postHook = postHook;
+    this.hookType = preHook;
+    this.timingKey = timingKey;
+  }
+  execute(context) {
+    if (context.hookType === this.preHook) {
+      context.data[`${this.timingKey}Start`] = performance.now();
+    } else if (context.hookType === this.postHook) {
+      const start = context.data[`${this.timingKey}Start`];
+      if (start) {
+        const duration = performance.now() - start;
+        context.data[`${this.timingKey}Ms`] = duration;
+      }
+    }
+    return context;
+  }
+};
+var MetricsHook = class {
+  hookType;
+  priority = 0;
+  count = 0;
+  errors = 0;
+  constructor(hookType) {
+    this.hookType = hookType;
+  }
+  execute(context) {
+    this.count++;
+    if (context.error) {
+      this.errors++;
+    }
+    return context;
+  }
+  reset() {
+    this.count = 0;
+    this.errors = 0;
+  }
+};
+var CachingHook = class {
+  hookType = "pre_resolve" /* PRE_RESOLVE */;
+  priority = 100;
+  // Run early to check cache
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  execute(context) {
+    if (context.hookType === "pre_resolve" /* PRE_RESOLVE */) {
+      const query = context.data.query;
+      if (query && this.cache.has(query)) {
+        context.data.cachedResults = this.cache.get(query);
+        context.data.cacheHit = true;
+      }
+    } else if (context.hookType === "post_resolve" /* POST_RESOLVE */) {
+      const query = context.data.query;
+      const results = context.data.results;
+      if (query && results && !this.cache.has(query)) {
+        if (this.cache.size >= this.maxSize) {
+          const firstKey = this.cache.keys().next().value;
+          if (firstKey) {
+            this.cache.delete(firstKey);
+          }
+        }
+        this.cache.set(query, results);
+      }
+    }
+    return context;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  get cacheSize() {
+    return this.cache.size;
+  }
+};
+
+// src/validators.ts
+function createValidationResult(valid, errors = [], warnings = []) {
+  return { valid, errors, warnings };
+}
+function mergeValidationResults(a, b) {
+  return {
+    valid: a.valid && b.valid,
+    errors: [...a.errors, ...b.errors],
+    warnings: [...a.warnings, ...b.warnings]
+  };
+}
+var ValidationError = class extends Error {
+  result;
+  constructor(result) {
+    super(`Validation failed: ${result.errors.join(", ")}`);
+    this.name = "ValidationError";
+    this.result = result;
+  }
+};
+var ALLOWED_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "integer",
+  "number",
+  "boolean",
+  "array",
+  "object",
+  "null"
+]);
+var ToolSchemaValidator = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      requireDescription: options.requireDescription ?? true,
+      requireParameters: options.requireParameters ?? false,
+      minDescriptionLength: options.minDescriptionLength ?? 0,
+      maxDescriptionLength: options.maxDescriptionLength ?? 1e3
+    };
+  }
+  validate(tool) {
+    const errors = [];
+    const warnings = [];
+    if (!tool.name) {
+      errors.push("Tool name is required");
+    } else if (!/^[\w-]+$/.test(tool.name)) {
+      warnings.push(`Tool name '${tool.name}' contains special characters`);
+    }
+    if (this.options.requireDescription && !tool.description) {
+      errors.push("Tool description is required");
+    } else if (tool.description) {
+      if (tool.description.length < this.options.minDescriptionLength) {
+        errors.push(
+          `Description must be at least ${this.options.minDescriptionLength} characters`
+        );
+      }
+      if (tool.description.length > this.options.maxDescriptionLength) {
+        errors.push(
+          `Description must be at most ${this.options.maxDescriptionLength} characters`
+        );
+      }
+    }
+    if (this.options.requireParameters && Object.keys(tool.parameters).length === 0) {
+      errors.push("Tool parameters are required");
+    }
+    for (const [name, param] of Object.entries(tool.parameters)) {
+      if (param.type && !ALLOWED_TYPES.has(param.type)) {
+        errors.push(`Parameter '${name}' has invalid type '${param.type}'`);
+      }
+    }
+    return createValidationResult(errors.length === 0, errors, warnings);
+  }
+};
+var ParameterValidator = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      strict: options.strict ?? false,
+      allowExtra: options.allowExtra ?? true
+    };
+  }
+  validate(data) {
+    const { tool, params } = data;
+    const errors = [];
+    const warnings = [];
+    if (!tool) {
+      errors.push("Tool is required for parameter validation");
+      return createValidationResult(false, errors, warnings);
+    }
+    const properties = tool.parameters;
+    if (this.options.strict) {
+      for (const [name, param] of Object.entries(properties)) {
+        if (param.required !== false && !(name in params)) {
+          errors.push(`Missing required parameter: ${name}`);
+        }
+      }
+    }
+    for (const [name, value] of Object.entries(params)) {
+      if (!(name in properties)) {
+        if (!this.options.allowExtra) {
+          errors.push(`Unknown parameter: ${name}`);
+        } else {
+          warnings.push(`Extra parameter provided: ${name}`);
+        }
+        continue;
+      }
+      const param = properties[name];
+      const typeError = this.checkType(name, value, param.type);
+      if (typeError) {
+        errors.push(typeError);
+      }
+    }
+    return createValidationResult(errors.length === 0, errors, warnings);
+  }
+  checkType(name, value, expectedType) {
+    if (!expectedType) return null;
+    const typeMap = {
+      string: (v) => typeof v === "string",
+      integer: (v) => Number.isInteger(v),
+      number: (v) => typeof v === "number",
+      boolean: (v) => typeof v === "boolean",
+      array: (v) => Array.isArray(v),
+      object: (v) => typeof v === "object" && v !== null && !Array.isArray(v),
+      null: (v) => v === null
+    };
+    const checker = typeMap[expectedType];
+    if (checker && !checker(value)) {
+      return `Parameter '${name}' expected ${expectedType}, got ${typeof value}`;
+    }
+    return null;
+  }
+};
+var ResultValidator = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      strict: options.strict ?? false
+    };
+  }
+  validate(data) {
+    const { tool, result } = data;
+    const errors = [];
+    const warnings = [];
+    if (!tool) {
+      errors.push("Tool is required for result validation");
+      return createValidationResult(false, errors, warnings);
+    }
+    if (tool.returns) {
+      const expectedType = tool.returns.type;
+      const typeError = this.checkReturnType(result, expectedType);
+      if (typeError) {
+        if (this.options.strict) {
+          errors.push(typeError);
+        } else {
+          warnings.push(typeError);
+        }
+      }
+    }
+    return createValidationResult(errors.length === 0, errors, warnings);
+  }
+  checkReturnType(value, expectedType) {
+    if (!expectedType) return null;
+    const typeMap = {
+      string: (v) => typeof v === "string",
+      integer: (v) => Number.isInteger(v),
+      number: (v) => typeof v === "number",
+      boolean: (v) => typeof v === "boolean",
+      array: (v) => Array.isArray(v),
+      object: (v) => typeof v === "object" && v !== null && !Array.isArray(v),
+      null: (v) => v === null
+    };
+    const checker = typeMap[expectedType];
+    if (checker && !checker(value)) {
+      return `Result expected ${expectedType}, got ${typeof value}`;
+    }
+    return null;
+  }
+};
+var EmbeddingValidator = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  validate(embedding) {
+    const errors = [];
+    const warnings = [];
+    if (!Array.isArray(embedding)) {
+      errors.push("Embedding must be an array");
+      return createValidationResult(false, errors, warnings);
+    }
+    if (embedding.length === 0) {
+      errors.push("Embedding cannot be empty");
+      return createValidationResult(false, errors, warnings);
+    }
+    if (this.options.expectedDimensions !== void 0 && embedding.length !== this.options.expectedDimensions) {
+      errors.push(
+        `Embedding dimensions mismatch: expected ${this.options.expectedDimensions}, got ${embedding.length}`
+      );
+    }
+    for (let i = 0; i < embedding.length; i++) {
+      if (typeof embedding[i] !== "number") {
+        errors.push(`Embedding value at index ${i} is not numeric`);
+        break;
+      }
+    }
+    if (this.options.checkNormalization && errors.length === 0) {
+      let sumSquares = 0;
+      for (const val of embedding) {
+        sumSquares += val * val;
+      }
+      const norm = Math.sqrt(sumSquares);
+      if (Math.abs(norm - 1) > 0.01) {
+        warnings.push(`Embedding is not normalized (norm=${norm.toFixed(4)})`);
+      }
+    }
+    return createValidationResult(errors.length === 0, errors, warnings);
+  }
+};
+var CompositeValidator = class {
+  validators;
+  constructor(validators) {
+    this.validators = validators;
+  }
+  validate(data) {
+    let result = createValidationResult(true);
+    for (const validator of this.validators) {
+      const subResult = validator.validate(data);
+      result = mergeValidationResults(result, subResult);
+    }
+    return result;
+  }
+};
+var ValidatorRegistry = class {
+  schemaValidators = [];
+  parameterValidators = [];
+  resultValidators = [];
+  embeddingValidators = [];
+  addSchemaValidator(validator) {
+    this.schemaValidators.push(validator);
+  }
+  addParameterValidator(validator) {
+    this.parameterValidators.push(validator);
+  }
+  addResultValidator(validator) {
+    this.resultValidators.push(validator);
+  }
+  addEmbeddingValidator(validator) {
+    this.embeddingValidators.push(validator);
+  }
+  validateTool(tool) {
+    let result = createValidationResult(true);
+    for (const validator of this.schemaValidators) {
+      const subResult = validator.validate(tool);
+      result = mergeValidationResults(result, subResult);
+    }
+    return result;
+  }
+  validateParams(tool, params) {
+    let result = createValidationResult(true);
+    for (const validator of this.parameterValidators) {
+      const subResult = validator.validate({ tool, params });
+      result = mergeValidationResults(result, subResult);
+    }
+    return result;
+  }
+  validateResult(tool, resultValue) {
+    let result = createValidationResult(true);
+    for (const validator of this.resultValidators) {
+      const subResult = validator.validate({ tool, result: resultValue });
+      result = mergeValidationResults(result, subResult);
+    }
+    return result;
+  }
+  validateEmbedding(embedding) {
+    let result = createValidationResult(true);
+    for (const validator of this.embeddingValidators) {
+      const subResult = validator.validate(embedding);
+      result = mergeValidationResults(result, subResult);
+    }
+    return result;
+  }
+  clear() {
+    this.schemaValidators = [];
+    this.parameterValidators = [];
+    this.resultValidators = [];
+    this.embeddingValidators = [];
+  }
+};
+function createStrictValidator() {
+  const registry = new ValidatorRegistry();
+  registry.addSchemaValidator(
+    new ToolSchemaValidator({
+      requireDescription: true,
+      minDescriptionLength: 10
+    })
+  );
+  registry.addParameterValidator(new ParameterValidator({ strict: true }));
+  registry.addResultValidator(new ResultValidator({ strict: true }));
+  return registry;
+}
+function createLenientValidator() {
+  const registry = new ValidatorRegistry();
+  registry.addSchemaValidator(
+    new ToolSchemaValidator({
+      requireDescription: false,
+      minDescriptionLength: 0
+    })
+  );
+  registry.addParameterValidator(
+    new ParameterValidator({
+      strict: false,
+      allowExtra: true
+    })
+  );
+  registry.addResultValidator(new ResultValidator({ strict: false }));
+  return registry;
+}
+
+// src/sis.ts
+var SIS = class {
+  _embeddings;
+  _vectorStore;
+  _pendingTools;
+  _defaultTopK;
+  _defaultThreshold;
+  _initialized;
+  _remoteUrl;
+  _projectId;
+  // Customization systems
+  _similarity;
+  _scoring;
+  _hooks;
+  _validators;
+  _validateOnRegister;
+  _validateOnExecute;
+  constructor(options = {}) {
+    const {
+      embeddingProvider = "openai",
+      defaultTopK = 5,
+      defaultThreshold = 0.3,
+      providerOptions = {},
+      similarity,
+      scoring,
+      validators,
+      validateOnRegister = false,
+      validateOnExecute = false
+    } = options;
+    if (typeof embeddingProvider === "string") {
+      this._embeddings = getProvider(embeddingProvider, providerOptions);
+    } else {
+      this._embeddings = embeddingProvider;
+    }
+    this._vectorStore = new VectorStore();
+    this._pendingTools = [];
+    this._defaultTopK = defaultTopK;
+    this._defaultThreshold = defaultThreshold;
+    this._initialized = false;
+    this._remoteUrl = options.remoteUrl;
+    this._projectId = options.projectId;
+    this._similarity = similarity ?? DEFAULT_SIMILARITY;
+    this._scoring = scoring ?? DEFAULT_SCORING;
+    this._hooks = new HookRegistry();
+    this._validators = validators;
+    this._validateOnRegister = validateOnRegister;
+    this._validateOnExecute = validateOnExecute;
+  }
+  // Properties for accessing customization systems
+  /** Get the hook registry for registering middleware */
+  get hooks() {
+    return this._hooks;
+  }
+  /** Get the validator registry */
+  get validators() {
+    return this._validators;
+  }
+  /** Get the current similarity function */
+  get similarity() {
+    return this._similarity;
+  }
+  /** Set a new similarity function */
+  set similarity(fn) {
+    this._similarity = fn;
+  }
+  /** Get the current scoring function */
+  get scoring() {
+    return this._scoring;
+  }
+  /** Set a new scoring function */
+  set scoring(fn) {
+    this._scoring = fn;
+  }
+  /** Register a hook */
+  registerHook(hook) {
+    this._hooks.register(hook);
+  }
+  /** Unregister a hook */
+  unregisterHook(hook) {
+    return this._hooks.unregister(hook);
+  }
+  /**
+   * Register a tool programmatically
+   */
+  register(options) {
+    const tool = {
+      name: options.name,
+      description: options.description,
+      parameters: options.parameters ?? {},
+      semanticHints: options.semanticHints ?? [],
+      examples: options.examples ?? [],
+      handler: options.handler,
+      metadata: options.metadata ?? {}
+    };
+    if (this._validateOnRegister && this._validators) {
+      const result = this._validators.validateTool(tool);
+      if (!result.valid) {
+        throw new ValidationError(result);
+      }
+    }
+    this._pendingTools.push(tool);
+    return tool;
+  }
+  /**
+   * Store (upsert) a tool with a precomputed embedding.
+   *
+   * This bypasses the embedding provider, allowing custom embedding workflows.
+   */
+  store(options) {
+    const tool = {
+      name: options.name,
+      description: options.description,
+      parameters: options.parameters ?? {},
+      semanticHints: options.semanticHints ?? [],
+      examples: options.examples ?? [],
+      handler: options.handler,
+      metadata: options.metadata ?? {}
+    };
+    if (this._validateOnRegister && this._validators) {
+      const result = this._validators.validateTool(tool);
+      if (!result.valid) {
+        throw new ValidationError(result);
+      }
+    }
+    if (this._validators) {
+      const embeddingResult = this._validators.validateEmbedding(options.embedding);
+      if (!embeddingResult.valid) {
+        throw new ValidationError(embeddingResult);
+      }
+    }
+    if (options.embedding.length !== this._embeddings.dimensions) {
+      throw new Error(
+        `Embedding dimensions must match provider: ${options.embedding.length} !== ${this._embeddings.dimensions}`
+      );
+    }
+    if (this._vectorStore.has(tool.name)) {
+      this._vectorStore.remove(tool.name);
+    }
+    this._vectorStore.add(tool, options.embedding);
+    return tool;
+  }
+  /**
+   * Initialize embeddings for all pending tools
+   */
+  async initialize() {
+    if (this._pendingTools.length === 0) {
+      this._initialized = true;
+      return;
+    }
+    let ctx = createContext("pre_embed" /* PRE_EMBED */, { tools: this._pendingTools });
+    ctx = await this._hooks.run("pre_embed" /* PRE_EMBED */, ctx);
+    if (ctx.cancelled) {
+      return;
+    }
+    const texts = this._pendingTools.map(
+      (tool) => buildToolText(
+        tool.name,
+        tool.description,
+        tool.semanticHints,
+        tool.examples
+      )
+    );
+    const embeddings = await this._embeddings.embedBatch(texts);
+    this._vectorStore.addBatch(this._pendingTools, embeddings);
+    ctx = createContext("post_embed" /* POST_EMBED */, {
+      tools: this._pendingTools,
+      embeddings
+    });
+    await this._hooks.run("post_embed" /* POST_EMBED */, ctx);
+    this._pendingTools = [];
+    this._initialized = true;
+  }
+  /**
+   * Resolve tools for a query
+   */
+  async resolve(query, options = {}) {
+    if (!this._initialized) {
+      await this.initialize();
+    }
+    const topK = options.topK ?? this._defaultTopK;
+    const threshold = options.threshold ?? this._defaultThreshold;
+    const format = options.format ?? "raw";
+    let ctx = createContext("pre_resolve" /* PRE_RESOLVE */, {
+      query,
+      topK,
+      threshold,
+      format
+    });
+    ctx = await this._hooks.run("pre_resolve" /* PRE_RESOLVE */, ctx);
+    if (ctx.cancelled) {
+      if (ctx.data.cachedResults) {
+        return ctx.data.cachedResults;
+      }
+      return [];
+    }
+    const finalQuery = ctx.data.query ?? query;
+    const finalTopK = ctx.data.topK ?? topK;
+    const finalThreshold = ctx.data.threshold ?? threshold;
+    if (this._remoteUrl && this._projectId) {
+      const response = await fetch(
+        `${this._remoteUrl}/v1/projects/${this._projectId}/resolve`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: finalQuery, top_k: finalTopK, threshold: finalThreshold })
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Remote resolution failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const results2 = data.results;
+      return this.formatResults(results2, format);
+    }
+    const queryEmbedding = await this._embeddings.embed(finalQuery);
+    let searchCtx = createContext("pre_search" /* PRE_SEARCH */, {
+      query: finalQuery,
+      queryEmbedding,
+      topK: finalTopK,
+      threshold: finalThreshold
+    });
+    searchCtx = await this._hooks.run("pre_search" /* PRE_SEARCH */, searchCtx);
+    const matches = this._vectorStore.search(
+      queryEmbedding,
+      finalTopK,
+      finalThreshold,
+      this._similarity,
+      this._scoring
+    );
+    let postSearchCtx = createContext("post_search" /* POST_SEARCH */, {
+      query: finalQuery,
+      matches
+    });
+    postSearchCtx = await this._hooks.run("post_search" /* POST_SEARCH */, postSearchCtx);
+    const finalMatches = postSearchCtx.data.matches ?? matches;
+    const resolved = finalMatches.map((match) => ({
+      name: match.tool.name,
+      schema: toSchema(match.tool),
+      score: match.score,
+      handler: match.tool.handler
+    }));
+    const results = this.formatResults(resolved, format);
+    let postCtx = createContext("post_resolve" /* POST_RESOLVE */, {
+      query: finalQuery,
+      results,
+      resolved
+    });
+    postCtx = await this._hooks.run("post_resolve" /* POST_RESOLVE */, postCtx);
+    return postCtx.data.results ?? results;
+  }
+  /**
+   * Format results based on format option
+   */
+  formatResults(resolved, format) {
+    if (format === "raw") {
+      return resolved;
+    }
+    if (typeof format === "object" && "format" in format) {
+      return formatTools(resolved, format);
+    }
+    if (typeof format === "string") {
+      if (hasFormatter(format)) {
+        return formatTools(resolved, format);
+      }
+      if (format === "openai") {
+        return resolved.map((r) => ({
+          type: "function",
+          function: r.schema
+        }));
+      }
+      if (format === "anthropic") {
+        return resolved.map((r) => ({
+          name: r.schema.name,
+          description: r.schema.description,
+          input_schema: r.schema.parameters
+        }));
+      }
+      throw new Error(`Unknown format: ${format}`);
+    }
+    return resolved;
+  }
+  /**
+   * Resolve the single best matching tool
+   */
+  async resolveOne(query, threshold) {
+    const results = await this.resolve(query, { topK: 1, threshold });
+    return results.length > 0 ? results[0] : null;
+  }
+  /**
+   * Get a registered tool by name
+   */
+  getTool(name) {
+    return this._vectorStore.get(name);
+  }
+  /**
+   * List all registered tool names
+   */
+  listTools() {
+    return this._vectorStore.getAll().map((t) => t.name);
+  }
+  /**
+   * Number of registered tools
+   */
+  get toolCount() {
+    return this._vectorStore.size + this._pendingTools.length;
+  }
+  /**
+   * Execute a tool by name
+   */
+  async execute(toolName, params) {
+    const tool = this._vectorStore.get(toolName);
+    if (!tool) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+    if (!tool.handler) {
+      throw new Error(`Tool has no handler: ${toolName}`);
+    }
+    let ctx = createContext("pre_execute" /* PRE_EXECUTE */, {
+      tool,
+      toolName,
+      params
+    });
+    ctx = await this._hooks.run("pre_execute" /* PRE_EXECUTE */, ctx);
+    if (ctx.cancelled) {
+      if (ctx.error) {
+        throw ctx.error;
+      }
+      return null;
+    }
+    if (this._validateOnExecute && this._validators) {
+      const paramsResult = this._validators.validateParams(tool, params);
+      if (!paramsResult.valid) {
+        throw new ValidationError(paramsResult);
+      }
+    }
+    const result = await tool.handler(params);
+    if (this._validateOnExecute && this._validators) {
+      const resultValidation = this._validators.validateResult(tool, result);
+      if (!resultValidation.valid) {
+        throw new ValidationError(resultValidation);
+      }
+    }
+    let postCtx = createContext("post_execute" /* POST_EXECUTE */, {
+      tool,
+      toolName,
+      params,
+      result
+    });
+    postCtx = await this._hooks.run("post_execute" /* POST_EXECUTE */, postCtx);
+    return postCtx.data.result ?? result;
+  }
+};
+
+exports.AnthropicFormatter = AnthropicFormatter;
+exports.CachingHook = CachingHook;
+exports.CohereEmbeddings = CohereEmbeddings;
+exports.CohereFormatter = CohereFormatter;
+exports.CompositeScoring = CompositeScoring;
+exports.CompositeValidator = CompositeValidator;
+exports.CosineSimilarity = CosineSimilarity;
+exports.DEFAULT_SCORING = DEFAULT_SCORING;
+exports.DEFAULT_SIMILARITY = DEFAULT_SIMILARITY;
+exports.DotProductSimilarity = DotProductSimilarity;
+exports.EmbeddingValidator = EmbeddingValidator;
+exports.EuclideanSimilarity = EuclideanSimilarity;
+exports.GeminiFormatter = GeminiFormatter;
+exports.GoogleEmbeddings = GoogleEmbeddings;
+exports.HookRegistry = HookRegistry;
+exports.HookType = HookType;
+exports.LlamaFormatter = LlamaFormatter;
+exports.LoggingHook = LoggingHook;
+exports.MetricsHook = MetricsHook;
+exports.MinimalFormatter = MinimalFormatter;
+exports.MistralFormatter = MistralFormatter;
+exports.OpenAIEmbeddings = OpenAIEmbeddings;
+exports.OpenAIFormatter = OpenAIFormatter;
+exports.ParameterValidator = ParameterValidator;
+exports.PriorityScoring = PriorityScoring;
+exports.RawFormatter = RawFormatter;
+exports.ResultValidator = ResultValidator;
+exports.SIS = SIS;
+exports.TagBoostScoring = TagBoostScoring;
+exports.TimingHook = TimingHook;
+exports.ToolSchemaValidator = ToolSchemaValidator;
+exports.ValidationError = ValidationError;
+exports.ValidatorRegistry = ValidatorRegistry;
+exports.VectorStore = VectorStore;
+exports.VerboseFormatter = VerboseFormatter;
+exports.WeightedScoring = WeightedScoring;
+exports.cancelContext = cancelContext;
+exports.createContext = createContext;
+exports.createHook = createHook;
+exports.createLenientValidator = createLenientValidator;
+exports.createStrictValidator = createStrictValidator;
+exports.createValidationResult = createValidationResult;
+exports.formatTools = formatTools;
+exports.getFormatter = getFormatter;
+exports.getProvider = getProvider;
+exports.hasFormatter = hasFormatter;
+exports.listFormatters = listFormatters;
+exports.mergeValidationResults = mergeValidationResults;
+exports.registerFormatter = registerFormatter;
+exports.setContextError = setContextError;
+exports.toAnthropicSchema = toAnthropicSchema;
+exports.toOpenAISchema = toOpenAISchema;
+exports.toSchema = toSchema;
+exports.unregisterFormatter = unregisterFormatter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map