@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-CDHS2QDC.js

@@ -0,0 +1,179 @@
+// src/completion/BuiltinToolExecutor.ts
+var DEFAULT_SEARCH_COUNT = 5;
+var DEFAULT_FETCH_MAX_CHARS = 2e4;
+var FALLBACK_ORDER = [
+  "tavily",
+  "jina",
+  "searxng",
+  "zhipu",
+  "z.ai",
+  "bocha",
+  "grok",
+  "local-google",
+  "local-bing",
+  "local-baidu",
+  "local-duckduckgo"
+];
+var IMPLICIT_LOCAL_FALLBACK = "local-google";
+var WEB_SEARCH_TOOL = {
+  id: "builtin__web_search",
+  serverId: "builtin",
+  serverName: "builtin",
+  name: "web_search",
+  description: "Search the web for current information. Returns a list of results with title, URL, and snippet. Use web_fetch afterwards to get full page content if snippets are insufficient.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "The search query." },
+      count: { type: "integer", description: "Maximum number of results (1-10).", default: DEFAULT_SEARCH_COUNT }
+    },
+    required: ["query"]
+  },
+  type: "mcp",
+  isBuiltIn: true
+};
+var WEB_FETCH_TOOL = {
+  id: "builtin__web_fetch",
+  serverId: "builtin",
+  serverName: "builtin",
+  name: "web_fetch",
+  description: "Fetch and extract the main content of a web page as clean Markdown. Use this to read the full content of a URL found via web_search.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "The URL to fetch (http or https)." },
+      maxChars: { type: "integer", description: "Maximum characters to return.", default: DEFAULT_FETCH_MAX_CHARS }
+    },
+    required: ["url"]
+  },
+  type: "mcp",
+  isBuiltIn: true
+};
+var BuiltinToolExecutor = class {
+  constructor(webSearch) {
+    this.webSearch = webSearch;
+  }
+  webSearch;
+  async execute(toolName, args) {
+    switch (toolName) {
+      case "web_search":
+        return this.executeWebSearch(args);
+      case "web_fetch":
+        return this.executeWebFetch(args);
+      default:
+        return { isError: true, content: [{ type: "text", text: `Unknown built-in tool: ${toolName}` }] };
+    }
+  }
+  // -----------------------------------------------------------------------
+  // web_search
+  // -----------------------------------------------------------------------
+  async executeWebSearch(args) {
+    const query = String(args.query ?? "").trim();
+    if (!query) {
+      return { isError: true, content: [{ type: "text", text: "Error: query parameter is required." }] };
+    }
+    const count = Math.min(Math.max(Number(args.count ?? DEFAULT_SEARCH_COUNT), 1), 10);
+    const chain = this.resolveProviderChain();
+    let lastError = "";
+    for (const providerId of chain) {
+      try {
+        const result = await this.webSearch.search(query, providerId, { maxResults: count });
+        if (!result.success) {
+          lastError = result.error || "Unknown error";
+          console.log(`[BuiltinToolExecutor] Search provider ${providerId} failed: ${lastError}, trying next...`);
+          continue;
+        }
+        const items = result.results.slice(0, count);
+        if (items.length === 0) {
+          console.log(`[BuiltinToolExecutor] Search provider ${providerId} returned 0 results, trying next...`);
+          continue;
+        }
+        const text = items.map((r, i) => `${i + 1}. ${r.title}
+   URL: ${r.url}
+   ${r.content || ""}`).join("\n\n");
+        return { isError: false, content: [{ type: "text", text }] };
+      } catch (err) {
+        lastError = err instanceof Error ? err.message : String(err);
+        console.log(`[BuiltinToolExecutor] Search provider ${providerId} threw: ${lastError}, trying next...`);
+        continue;
+      }
+    }
+    return {
+      isError: false,
+      content: [{ type: "text", text: lastError ? `Search failed after trying ${chain.length} provider(s). Last error: ${lastError}` : `No results found for "${query}" after trying ${chain.length} provider(s). Try rephrasing your search.` }]
+    };
+  }
+  resolveProviderChain() {
+    const chain = [];
+    for (const id of FALLBACK_ORDER) {
+      if (this.webSearch.isProviderEnabled(id)) {
+        chain.push(id);
+      }
+    }
+    if (!chain.includes(IMPLICIT_LOCAL_FALLBACK)) {
+      chain.push(IMPLICIT_LOCAL_FALLBACK);
+    }
+    return chain;
+  }
+  // -----------------------------------------------------------------------
+  // web_fetch
+  // -----------------------------------------------------------------------
+  async executeWebFetch(args) {
+    const url = String(args.url ?? "").trim();
+    if (!url) {
+      return { isError: true, content: [{ type: "text", text: "Error: url parameter is required." }] };
+    }
+    try {
+      const parsed = new URL(url);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return { isError: true, content: [{ type: "text", text: "Error: only http and https URLs are supported." }] };
+      }
+    } catch {
+      return { isError: true, content: [{ type: "text", text: `Error: invalid URL "${url}".` }] };
+    }
+    const maxChars = Number(args.maxChars ?? DEFAULT_FETCH_MAX_CHARS);
+    try {
+      const jinaResult = await this.webSearch.readUrl(url, { timeout: 15e3 });
+      if (jinaResult.success && jinaResult.content) {
+        const content = jinaResult.content.length > maxChars ? jinaResult.content.slice(0, maxChars) + "\n\n[Content truncated]" : jinaResult.content;
+        const header = jinaResult.title ? `# ${jinaResult.title}
+
+` : "";
+        return { isError: false, content: [{ type: "text", text: header + content }] };
+      }
+      const { fetchAndExtractUrl } = await import("./builtin-web-fetch-IGLBX2XY.js");
+      const text = await fetchAndExtractUrl(url, maxChars);
+      return { isError: false, content: [{ type: "text", text }] };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { isError: true, content: [{ type: "text", text: `Fetch error: ${message}` }] };
+    }
+  }
+};
+function getBuiltinSearchTools() {
+  return [WEB_SEARCH_TOOL, WEB_FETCH_TOOL];
+}
+function convertBuiltinToolsToOpenAI(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.id,
+      description: t.description || t.name,
+      parameters: t.inputSchema
+    }
+  }));
+}
+function convertBuiltinToolsToAnthropic(tools) {
+  return tools.map((t) => ({
+    name: t.id,
+    description: t.description || t.name,
+    input_schema: t.inputSchema
+  }));
+}
+
+export {
+  BuiltinToolExecutor,
+  getBuiltinSearchTools,
+  convertBuiltinToolsToOpenAI,
+  convertBuiltinToolsToAnthropic
+};

package/dist/chunk-DK4A7DLE.js

@@ -0,0 +1,266 @@
+// src/transformer/TransformerService.ts
+var defaultLogger = {
+  debug: (msg, ...args) => console.debug(`[TransformerService] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[TransformerService] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[TransformerService] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[TransformerService] ${msg}`, ...args)
+};
+var TransformerService = class {
+  transformers = /* @__PURE__ */ new Map();
+  logger;
+  // Performance optimization: Cache instantiated transformers
+  instanceCache = /* @__PURE__ */ new Map();
+  // Performance optimization: Cache endpoint transformer results
+  endpointTransformersCache = null;
+  noEndpointTransformersCache = null;
+  constructor(logger) {
+    this.logger = logger ?? defaultLogger;
+  }
+  /**
+   * Clear instance caches
+   */
+  clearInstanceCache() {
+    this.instanceCache.clear();
+    this.endpointTransformersCache = null;
+    this.noEndpointTransformersCache = null;
+  }
+  /**
+   * Get cache statistics for diagnostics
+   */
+  getCacheStats() {
+    return {
+      instanceCacheSize: this.instanceCache.size,
+      hasEndpointCache: this.endpointTransformersCache !== null
+    };
+  }
+  /**
+   * Register a transformer by name
+   * @param name - Unique transformer name
+   * @param transformer - Transformer instance or constructor
+   */
+  registerTransformer(name, transformer) {
+    this.transformers.set(name, transformer);
+    this.clearInstanceCache();
+    const endpoint = "endPoint" in transformer ? transformer.endPoint : "prototype" in transformer && transformer.prototype?.endPoint ? transformer.prototype.endPoint : void 0;
+    this.logger.info(
+      `Registered transformer: ${name}${endpoint ? ` (endpoint: ${endpoint})` : " (no endpoint)"}`
+    );
+  }
+  /**
+   * Get a transformer by name
+   * @param name - Transformer name
+   * @returns Transformer instance/constructor or undefined
+   */
+  getTransformer(name) {
+    return this.transformers.get(name);
+  }
+  /**
+   * Get all registered transformers
+   * @returns Map of all transformers
+   */
+  getAllTransformers() {
+    return new Map(this.transformers);
+  }
+  /**
+   * Get transformers that have an endpoint defined
+   * Uses cache to avoid redundant traversal
+   * @returns Array of transformers with endpoints
+   */
+  getTransformersWithEndpoint() {
+    if (this.endpointTransformersCache) {
+      return this.endpointTransformersCache;
+    }
+    const result = [];
+    this.transformers.forEach((transformer, name) => {
+      const instance = this.instantiateIfNeeded(transformer);
+      if (instance?.endPoint) {
+        result.push({ name, transformer: instance });
+      }
+    });
+    this.endpointTransformersCache = result;
+    return result;
+  }
+  /**
+   * Get transformers without endpoints
+   * Uses cache to avoid redundant traversal
+   * @returns Array of transformers without endpoints
+   */
+  getTransformersWithoutEndpoint() {
+    if (this.noEndpointTransformersCache) {
+      return this.noEndpointTransformersCache;
+    }
+    const result = [];
+    this.transformers.forEach((transformer, name) => {
+      const instance = this.instantiateIfNeeded(transformer);
+      if (instance && !instance.endPoint) {
+        result.push({ name, transformer: instance });
+      }
+    });
+    this.noEndpointTransformersCache = result;
+    return result;
+  }
+  /**
+   * Remove a transformer by name
+   * @param name - Transformer name
+   * @returns true if removed, false if not found
+   */
+  removeTransformer(name) {
+    const removed = this.transformers.delete(name);
+    if (removed) {
+      this.clearInstanceCache();
+    }
+    return removed;
+  }
+  /**
+   * Check if a transformer is registered
+   * @param name - Transformer name
+   * @returns true if registered
+   */
+  hasTransformer(name) {
+    return this.transformers.has(name);
+  }
+  /**
+   * Initialize the service with default transformers
+   * @param defaultTransformers - Map or object of default transformers
+   */
+  async initialize(defaultTransformers) {
+    try {
+      if (defaultTransformers) {
+        await this.registerDefaultTransformers(defaultTransformers);
+      }
+      this.logger.info(
+        `TransformerService initialized with ${this.transformers.size} transformers`
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`TransformerService init error: ${errorMessage}`);
+      throw error;
+    }
+  }
+  /**
+   * Register default transformers from a map
+   * @param transformers - Map of transformer name to transformer
+   */
+  async registerDefaultTransformers(transformers) {
+    for (const [key, TransformerClass] of Object.entries(transformers)) {
+      try {
+        if (this.isTransformerConstructor(TransformerClass)) {
+          const staticName = TransformerClass.TransformerName ?? key;
+          this.registerTransformer(staticName, TransformerClass);
+        } else {
+          const name = TransformerClass.name ?? key;
+          TransformerClass.logger = this.logger;
+          this.registerTransformer(name, TransformerClass);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Failed to register transformer ${key}: ${errorMessage}`);
+      }
+    }
+  }
+  /**
+   * Resolve a transformer chain configuration to actual transformer instances
+   * @param chainConfig - Transformer chain configuration
+   * @param modelName - Model name for model-specific transformers
+   * @returns Resolved transformer chain with instances
+   */
+  resolveTransformerChain(chainConfig, modelName) {
+    const result = {
+      providerTransformers: [],
+      modelTransformers: []
+    };
+    if (!chainConfig) {
+      return result;
+    }
+    if (chainConfig.use) {
+      result.providerTransformers = this.resolveTransformerReferences(chainConfig.use);
+    }
+    if (modelName && chainConfig[modelName]) {
+      const modelConfig = chainConfig[modelName];
+      if (Array.isArray(modelConfig)) {
+        result.modelTransformers = this.resolveTransformerReferences(modelConfig);
+      } else if (modelConfig && typeof modelConfig === "object" && "use" in modelConfig) {
+        result.modelTransformers = this.resolveTransformerReferences(modelConfig.use ?? []);
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolve an array of transformer references to instances
+   * @param refs - Array of transformer references
+   * @returns Array of transformer instances
+   */
+  resolveTransformerReferences(refs) {
+    const instances = [];
+    for (const ref of refs) {
+      const [name, options] = Array.isArray(ref) ? ref : [ref, void 0];
+      const transformer = this.getTransformer(name);
+      if (!transformer) {
+        this.logger.warn(`Transformer not found: ${name}`);
+        continue;
+      }
+      const instance = this.instantiateIfNeeded(transformer, options);
+      if (instance) {
+        instance.logger = this.logger;
+        instances.push(instance);
+      }
+    }
+    return instances;
+  }
+  /**
+   * Instantiate a transformer if it's a constructor
+   * Uses instance cache to avoid redundant instantiation
+   *
+   * @param transformer - Transformer instance or constructor
+   * @param options - Options to pass to constructor
+   * @returns Transformer instance
+   */
+  instantiateIfNeeded(transformer, options) {
+    if (!this.isTransformerConstructor(transformer)) {
+      return transformer;
+    }
+    const constructorName = transformer.TransformerName || transformer.name || "anonymous";
+    const optionsHash = options ? JSON.stringify(options) : "";
+    const cacheKey = `${constructorName}:${optionsHash}`;
+    if (this.instanceCache.has(cacheKey)) {
+      return this.instanceCache.get(cacheKey);
+    }
+    try {
+      const instance = new transformer(options);
+      instance.logger = this.logger;
+      this.instanceCache.set(cacheKey, instance);
+      return instance;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to instantiate transformer: ${errorMessage}`);
+      return void 0;
+    }
+  }
+  /**
+   * Check if a value is a transformer constructor
+   * @param value - Value to check
+   * @returns true if it's a constructor
+   */
+  isTransformerConstructor(value) {
+    return typeof value === "function" && value.prototype && (typeof value.prototype.transformRequestIn === "function" || typeof value.prototype.transformRequestOut === "function" || typeof value.prototype.transformResponseIn === "function" || typeof value.prototype.transformResponseOut === "function" || "TransformerName" in value);
+  }
+  /**
+   * Get list of all registered transformer names
+   * @returns Array of transformer names
+   */
+  getTransformerNames() {
+    return Array.from(this.transformers.keys());
+  }
+  /**
+   * Clear all registered transformers
+   */
+  clear() {
+    this.transformers.clear();
+    this.clearInstanceCache();
+    this.logger.info("All transformers cleared");
+  }
+};
+
+export {
+  TransformerService
+};

package/dist/chunk-DRWHTIIZ.js

@@ -0,0 +1,13 @@
+// src/ports/gemini-code-assist-resolver.ts
+var resolver = null;
+function setGeminiCodeAssistResolver(impl) {
+  resolver = impl;
+}
+function getGeminiCodeAssistResolver() {
+  return resolver;
+}
+
+export {
+  setGeminiCodeAssistResolver,
+  getGeminiCodeAssistResolver
+};