@wingman-ai/gateway 0.3.1 → 0.4.0

package/dist/agent/config/mcpClientManager.cjs

@@ -52,15 +52,7 @@ class MCPClientManager {
             for (const [key, value] of Object.entries(stdioServer.env || {}))resolvedEnv[key] = resolveEnvValue(value);
             const runtimeEnv = this.applyRuntimeEnv(resolvedEnv);
             const defaultToolTimeout = getDefaultToolTimeout(stdioServer);
-            mcpServers[server.name] = {
-                transport: "stdio",
-                command: stdioServer.command,
-                args: stdioServer.args || [],
-                env: runtimeEnv,
-                ...void 0 !== defaultToolTimeout ? {
-                    defaultToolTimeout
-                } : {}
-            };
+            mcpServers[server.name] = this.buildStdioServerConfig(stdioServer, runtimeEnv, defaultToolTimeout);
         } else if ("sse" === server.transport) {
             const sseServer = server;
             const defaultToolTimeout = getDefaultToolTimeout(sseServer);
@@ -83,6 +75,51 @@ class MCPClientManager {
             }
         };
     }
+    buildStdioServerConfig(server, env, defaultToolTimeout) {
+        const baseConfig = {
+            transport: "stdio",
+            command: server.command,
+            args: server.args || [],
+            env,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+        if (!this.proxyConfig?.enabled) return baseConfig;
+        const proxyCommand = this.proxyConfig.command?.trim() || "uvx";
+        const proxyBaseArgs = this.proxyConfig.baseArgs && this.proxyConfig.baseArgs.length > 0 ? this.proxyConfig.baseArgs : [
+            "invariant-gateway@latest",
+            "mcp"
+        ];
+        const proxyEnv = {
+            ...env
+        };
+        if (this.proxyConfig.apiKey) proxyEnv.INVARIANT_API_KEY = this.proxyConfig.apiKey;
+        if (this.proxyConfig.apiUrl) {
+            proxyEnv.INVARIANT_API_URL = this.proxyConfig.apiUrl;
+            proxyEnv.GUARDRAILS_API_URL = this.proxyConfig.apiUrl;
+        }
+        const proxyArgs = [
+            ...proxyBaseArgs,
+            "--project-name",
+            this.proxyConfig.projectName || "wingman-gateway",
+            ...this.proxyConfig.pushExplorer ? [
+                "--push-explorer"
+            ] : [],
+            "--exec",
+            baseConfig.command,
+            ...baseConfig.args || []
+        ];
+        return {
+            transport: "stdio",
+            command: proxyCommand,
+            args: proxyArgs,
+            env: proxyEnv,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+    }
     applyRuntimeEnv(env) {
         if (!this.executionWorkspace) return env;
         const next = {
@@ -176,9 +213,11 @@ class MCPClientManager {
         _define_property(this, "logger", void 0);
         _define_property(this, "serverConfigs", void 0);
         _define_property(this, "executionWorkspace", void 0);
+        _define_property(this, "proxyConfig", void 0);
         this.logger = logger;
         this.serverConfigs = this.mergeConfigs(configs);
         this.executionWorkspace = options?.executionWorkspace?.trim() || null;
+        this.proxyConfig = options?.proxyConfig;
     }
 }
 function resolveEnvValue(value) {

package/dist/agent/config/mcpClientManager.d.ts

@@ -1,6 +1,15 @@
 import type { StructuredTool } from "@langchain/core/tools";
 import type { Logger } from "@/logger.js";
 import type { MCPServersConfig } from "@/types/mcp.js";
+export type MCPProxyConfig = {
+    enabled?: boolean;
+    command?: string;
+    baseArgs?: string[];
+    projectName?: string;
+    pushExplorer?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+};
 /**
  * Manages MCP server connections and tool retrieval
  * Handles server lifecycle: initialization, tool loading, and cleanup
@@ -10,8 +19,10 @@ export declare class MCPClientManager {
     private logger;
     private serverConfigs;
     private executionWorkspace;
+    private proxyConfig;
     constructor(configs: MCPServersConfig[], logger: Logger, options?: {
         executionWorkspace?: string | null;
+        proxyConfig?: MCPProxyConfig;
     });
     /**
      * Merge multiple MCP configurations (global + agent-specific)
@@ -22,6 +33,7 @@ export declare class MCPClientManager {
      * Convert Wingman MCP config to MultiServerMCPClient format
      */
     private buildClientConfig;
+    private buildStdioServerConfig;
     private applyRuntimeEnv;
     /**
      * Initialize MCP client and connect to servers

package/dist/agent/config/mcpClientManager.js

@@ -24,15 +24,7 @@ class MCPClientManager {
             for (const [key, value] of Object.entries(stdioServer.env || {}))resolvedEnv[key] = resolveEnvValue(value);
             const runtimeEnv = this.applyRuntimeEnv(resolvedEnv);
             const defaultToolTimeout = getDefaultToolTimeout(stdioServer);
-            mcpServers[server.name] = {
-                transport: "stdio",
-                command: stdioServer.command,
-                args: stdioServer.args || [],
-                env: runtimeEnv,
-                ...void 0 !== defaultToolTimeout ? {
-                    defaultToolTimeout
-                } : {}
-            };
+            mcpServers[server.name] = this.buildStdioServerConfig(stdioServer, runtimeEnv, defaultToolTimeout);
         } else if ("sse" === server.transport) {
             const sseServer = server;
             const defaultToolTimeout = getDefaultToolTimeout(sseServer);
@@ -55,6 +47,51 @@ class MCPClientManager {
             }
         };
     }
+    buildStdioServerConfig(server, env, defaultToolTimeout) {
+        const baseConfig = {
+            transport: "stdio",
+            command: server.command,
+            args: server.args || [],
+            env,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+        if (!this.proxyConfig?.enabled) return baseConfig;
+        const proxyCommand = this.proxyConfig.command?.trim() || "uvx";
+        const proxyBaseArgs = this.proxyConfig.baseArgs && this.proxyConfig.baseArgs.length > 0 ? this.proxyConfig.baseArgs : [
+            "invariant-gateway@latest",
+            "mcp"
+        ];
+        const proxyEnv = {
+            ...env
+        };
+        if (this.proxyConfig.apiKey) proxyEnv.INVARIANT_API_KEY = this.proxyConfig.apiKey;
+        if (this.proxyConfig.apiUrl) {
+            proxyEnv.INVARIANT_API_URL = this.proxyConfig.apiUrl;
+            proxyEnv.GUARDRAILS_API_URL = this.proxyConfig.apiUrl;
+        }
+        const proxyArgs = [
+            ...proxyBaseArgs,
+            "--project-name",
+            this.proxyConfig.projectName || "wingman-gateway",
+            ...this.proxyConfig.pushExplorer ? [
+                "--push-explorer"
+            ] : [],
+            "--exec",
+            baseConfig.command,
+            ...baseConfig.args || []
+        ];
+        return {
+            transport: "stdio",
+            command: proxyCommand,
+            args: proxyArgs,
+            env: proxyEnv,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+    }
     applyRuntimeEnv(env) {
         if (!this.executionWorkspace) return env;
         const next = {
@@ -148,9 +185,11 @@ class MCPClientManager {
         _define_property(this, "logger", void 0);
         _define_property(this, "serverConfigs", void 0);
         _define_property(this, "executionWorkspace", void 0);
+        _define_property(this, "proxyConfig", void 0);
         this.logger = logger;
         this.serverConfigs = this.mergeConfigs(configs);
         this.executionWorkspace = options?.executionWorkspace?.trim() || null;
+        this.proxyConfig = options?.proxyConfig;
     }
 }
 function resolveEnvValue(value) {

package/dist/agent/tests/internet_search.test.cjs

@@ -1,16 +1,6 @@
 "use strict";
 var __webpack_exports__ = {};
 const external_vitest_namespaceObject = require("vitest");
-function _define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
 const originalEnv = {
     ...process.env
 };
@@ -22,18 +12,14 @@ const loadSearchModule = async (overrides)=>{
     for (const [key, value] of Object.entries(overrides))if (void 0 === value) delete process.env[key];
     else process.env[key] = value;
     external_vitest_namespaceObject.vi.resetModules();
-    const callMock = external_vitest_namespaceObject.vi.fn();
-    external_vitest_namespaceObject.vi.doMock("@langchain/community/tools/duckduckgo_search", ()=>({
-            DuckDuckGoSearch: class {
-                constructor(){
-                    _define_property(this, "_call", callMock);
-                }
-            }
+    const searchMock = external_vitest_namespaceObject.vi.fn();
+    external_vitest_namespaceObject.vi.doMock("duck-duck-scrape", ()=>({
+            search: searchMock
         }));
     const module = await import("../tools/internet_search.cjs");
     return {
         ...module,
-        callMock
+        searchMock
     };
 };
 (0, external_vitest_namespaceObject.beforeEach)(()=>{
@@ -47,13 +33,21 @@ const loadSearchModule = async (overrides)=>{
 });
 (0, external_vitest_namespaceObject.describe)("Internet search tool (DuckDuckGo)", ()=>{
     (0, external_vitest_namespaceObject.it)("retries on DDG anomaly and succeeds", async ()=>{
-        const { createInternetSearchTool, callMock } = await loadSearchModule({
+        const { createInternetSearchTool, searchMock } = await loadSearchModule({
             WINGMAN_DDG_MIN_DELAY_MS: "0",
             WINGMAN_DDG_BACKOFF_BASE_MS: "1",
             WINGMAN_DDG_BACKOFF_MAX_MS: "1",
             WINGMAN_DDG_MAX_RETRIES: "2"
         });
-        callMock.mockRejectedValueOnce(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly.")).mockResolvedValueOnce("ok");
+        searchMock.mockRejectedValueOnce(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly.")).mockResolvedValueOnce({
+            results: [
+                {
+                    title: "Wingman",
+                    url: "https://wingman.ai",
+                    description: "Agentic coding assistant"
+                }
+            ]
+        });
         const tool = createInternetSearchTool({
             provider: "duckduckgo",
             maxResults: 3
@@ -61,19 +55,19 @@ const loadSearchModule = async (overrides)=>{
         const resultPromise = tool.invoke({
             query: "test"
         });
-        const expectation = (0, external_vitest_namespaceObject.expect)(resultPromise).resolves.toBe("ok");
+        const expectation = (0, external_vitest_namespaceObject.expect)(resultPromise).resolves.toContain("Wingman");
         await external_vitest_namespaceObject.vi.runAllTimersAsync();
         await expectation;
-        (0, external_vitest_namespaceObject.expect)(callMock).toHaveBeenCalledTimes(2);
+        (0, external_vitest_namespaceObject.expect)(searchMock).toHaveBeenCalledTimes(2);
     });
     (0, external_vitest_namespaceObject.it)("throws a friendly error after retry exhaustion", async ()=>{
-        const { createInternetSearchTool, callMock } = await loadSearchModule({
+        const { createInternetSearchTool, searchMock } = await loadSearchModule({
             WINGMAN_DDG_MIN_DELAY_MS: "0",
             WINGMAN_DDG_BACKOFF_BASE_MS: "1",
             WINGMAN_DDG_BACKOFF_MAX_MS: "1",
             WINGMAN_DDG_MAX_RETRIES: "1"
         });
-        callMock.mockRejectedValue(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly."));
+        searchMock.mockRejectedValue(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly."));
         const tool = createInternetSearchTool({
             provider: "duckduckgo",
             maxResults: 3
@@ -84,16 +78,16 @@ const loadSearchModule = async (overrides)=>{
         const expectation = (0, external_vitest_namespaceObject.expect)(resultPromise).rejects.toThrow(/rate-limited|anomaly/i);
         await external_vitest_namespaceObject.vi.runAllTimersAsync();
         await expectation;
-        (0, external_vitest_namespaceObject.expect)(callMock).toHaveBeenCalledTimes(2);
+        (0, external_vitest_namespaceObject.expect)(searchMock).toHaveBeenCalledTimes(2);
     });
     (0, external_vitest_namespaceObject.it)("does not retry on non-anomaly errors", async ()=>{
-        const { createInternetSearchTool, callMock } = await loadSearchModule({
+        const { createInternetSearchTool, searchMock } = await loadSearchModule({
             WINGMAN_DDG_MIN_DELAY_MS: "0",
             WINGMAN_DDG_BACKOFF_BASE_MS: "1",
             WINGMAN_DDG_BACKOFF_MAX_MS: "1",
             WINGMAN_DDG_MAX_RETRIES: "2"
         });
-        callMock.mockRejectedValue(new Error("network down"));
+        searchMock.mockRejectedValue(new Error("network down"));
         const tool = createInternetSearchTool({
             provider: "duckduckgo",
             maxResults: 3
@@ -104,7 +98,7 @@ const loadSearchModule = async (overrides)=>{
         const expectation = (0, external_vitest_namespaceObject.expect)(resultPromise).rejects.toThrow("network down");
         await external_vitest_namespaceObject.vi.runAllTimersAsync();
         await expectation;
-        (0, external_vitest_namespaceObject.expect)(callMock).toHaveBeenCalledTimes(1);
+        (0, external_vitest_namespaceObject.expect)(searchMock).toHaveBeenCalledTimes(1);
     });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/agent/tests/internet_search.test.js

@@ -1,14 +1,4 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-function _define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
 const originalEnv = {
     ...process.env
 };
@@ -20,18 +10,14 @@ const loadSearchModule = async (overrides)=>{
     for (const [key, value] of Object.entries(overrides))if (void 0 === value) delete process.env[key];
     else process.env[key] = value;
     vi.resetModules();
-    const callMock = vi.fn();
-    vi.doMock("@langchain/community/tools/duckduckgo_search", ()=>({
-            DuckDuckGoSearch: class {
-                constructor(){
-                    _define_property(this, "_call", callMock);
-                }
-            }
+    const searchMock = vi.fn();
+    vi.doMock("duck-duck-scrape", ()=>({
+            search: searchMock
         }));
     const module = await import("../tools/internet_search.js");
     return {
         ...module,
-        callMock
+        searchMock
     };
 };
 beforeEach(()=>{
@@ -45,13 +31,21 @@ afterEach(()=>{
 });
 describe("Internet search tool (DuckDuckGo)", ()=>{
     it("retries on DDG anomaly and succeeds", async ()=>{
-        const { createInternetSearchTool, callMock } = await loadSearchModule({
+        const { createInternetSearchTool, searchMock } = await loadSearchModule({
             WINGMAN_DDG_MIN_DELAY_MS: "0",
             WINGMAN_DDG_BACKOFF_BASE_MS: "1",
             WINGMAN_DDG_BACKOFF_MAX_MS: "1",
             WINGMAN_DDG_MAX_RETRIES: "2"
         });
-        callMock.mockRejectedValueOnce(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly.")).mockResolvedValueOnce("ok");
+        searchMock.mockRejectedValueOnce(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly.")).mockResolvedValueOnce({
+            results: [
+                {
+                    title: "Wingman",
+                    url: "https://wingman.ai",
+                    description: "Agentic coding assistant"
+                }
+            ]
+        });
         const tool = createInternetSearchTool({
             provider: "duckduckgo",
             maxResults: 3
@@ -59,19 +53,19 @@ describe("Internet search tool (DuckDuckGo)", ()=>{
         const resultPromise = tool.invoke({
             query: "test"
         });
-        const expectation = expect(resultPromise).resolves.toBe("ok");
+        const expectation = expect(resultPromise).resolves.toContain("Wingman");
         await vi.runAllTimersAsync();
         await expectation;
-        expect(callMock).toHaveBeenCalledTimes(2);
+        expect(searchMock).toHaveBeenCalledTimes(2);
     });
     it("throws a friendly error after retry exhaustion", async ()=>{
-        const { createInternetSearchTool, callMock } = await loadSearchModule({
+        const { createInternetSearchTool, searchMock } = await loadSearchModule({
             WINGMAN_DDG_MIN_DELAY_MS: "0",
             WINGMAN_DDG_BACKOFF_BASE_MS: "1",
             WINGMAN_DDG_BACKOFF_MAX_MS: "1",
             WINGMAN_DDG_MAX_RETRIES: "1"
         });
-        callMock.mockRejectedValue(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly."));
+        searchMock.mockRejectedValue(new Error("DDG detected an anomaly in the request, you are likely making requests too quickly."));
         const tool = createInternetSearchTool({
             provider: "duckduckgo",
             maxResults: 3
@@ -82,16 +76,16 @@ describe("Internet search tool (DuckDuckGo)", ()=>{
         const expectation = expect(resultPromise).rejects.toThrow(/rate-limited|anomaly/i);
         await vi.runAllTimersAsync();
         await expectation;
-        expect(callMock).toHaveBeenCalledTimes(2);
+        expect(searchMock).toHaveBeenCalledTimes(2);
     });
     it("does not retry on non-anomaly errors", async ()=>{
-        const { createInternetSearchTool, callMock } = await loadSearchModule({
+        const { createInternetSearchTool, searchMock } = await loadSearchModule({
             WINGMAN_DDG_MIN_DELAY_MS: "0",
             WINGMAN_DDG_BACKOFF_BASE_MS: "1",
             WINGMAN_DDG_BACKOFF_MAX_MS: "1",
             WINGMAN_DDG_MAX_RETRIES: "2"
         });
-        callMock.mockRejectedValue(new Error("network down"));
+        searchMock.mockRejectedValue(new Error("network down"));
         const tool = createInternetSearchTool({
             provider: "duckduckgo",
             maxResults: 3
@@ -102,6 +96,6 @@ describe("Internet search tool (DuckDuckGo)", ()=>{
         const expectation = expect(resultPromise).rejects.toThrow("network down");
         await vi.runAllTimersAsync();
         await expectation;
-        expect(callMock).toHaveBeenCalledTimes(1);
+        expect(searchMock).toHaveBeenCalledTimes(1);
     });
 });

package/dist/agent/tests/mcpClientManager.test.cjs

@@ -117,6 +117,56 @@ const getClientConfig = (manager)=>manager.buildClientConfig();
         const clientConfig = getClientConfig(manager);
         (0, external_vitest_namespaceObject.expect)(clientConfig.mcpServers["fal-ai"].defaultToolTimeout).toBe(300000);
     });
+    (0, external_vitest_namespaceObject.it)("wraps stdio servers with proxy command when enabled", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(configs, testLogger, {
+            proxyConfig: {
+                enabled: true,
+                command: "uvx",
+                baseArgs: [
+                    "invariant-gateway@latest",
+                    "mcp"
+                ],
+                projectName: "wingman-gateway",
+                apiKey: "test-api-key",
+                apiUrl: "https://explorer.invariantlabs.ai"
+            }
+        });
+        const clientConfig = getClientConfig(manager);
+        const server = clientConfig.mcpServers["fal-ai"];
+        (0, external_vitest_namespaceObject.expect)(server.command).toBe("uvx");
+        (0, external_vitest_namespaceObject.expect)(server.args).toEqual([
+            "invariant-gateway@latest",
+            "mcp",
+            "--project-name",
+            "wingman-gateway",
+            "--exec",
+            "bun",
+            "run",
+            "src/tools/mcp-fal-ai.ts"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(server.env.EXISTING).toBe("value");
+        (0, external_vitest_namespaceObject.expect)(server.env.INVARIANT_API_KEY).toBe("test-api-key");
+        (0, external_vitest_namespaceObject.expect)(server.env.INVARIANT_API_URL).toBe("https://explorer.invariantlabs.ai");
+        (0, external_vitest_namespaceObject.expect)(server.env.GUARDRAILS_API_URL).toBe("https://explorer.invariantlabs.ai");
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/agent/tests/mcpClientManager.test.js

@@ -115,4 +115,54 @@ describe("MCPClientManager runtime env", ()=>{
         const clientConfig = getClientConfig(manager);
         expect(clientConfig.mcpServers["fal-ai"].defaultToolTimeout).toBe(300000);
     });
+    it("wraps stdio servers with proxy command when enabled", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new MCPClientManager(configs, testLogger, {
+            proxyConfig: {
+                enabled: true,
+                command: "uvx",
+                baseArgs: [
+                    "invariant-gateway@latest",
+                    "mcp"
+                ],
+                projectName: "wingman-gateway",
+                apiKey: "test-api-key",
+                apiUrl: "https://explorer.invariantlabs.ai"
+            }
+        });
+        const clientConfig = getClientConfig(manager);
+        const server = clientConfig.mcpServers["fal-ai"];
+        expect(server.command).toBe("uvx");
+        expect(server.args).toEqual([
+            "invariant-gateway@latest",
+            "mcp",
+            "--project-name",
+            "wingman-gateway",
+            "--exec",
+            "bun",
+            "run",
+            "src/tools/mcp-fal-ai.ts"
+        ]);
+        expect(server.env.EXISTING).toBe("value");
+        expect(server.env.INVARIANT_API_KEY).toBe("test-api-key");
+        expect(server.env.INVARIANT_API_URL).toBe("https://explorer.invariantlabs.ai");
+        expect(server.env.GUARDRAILS_API_URL).toBe("https://explorer.invariantlabs.ai");
+    });
 });

package/dist/agent/tools/internet_search.cjs

@@ -28,7 +28,7 @@ __webpack_require__.d(__webpack_exports__, {
     internetSearch: ()=>internetSearch
 });
 const external_langchain_namespaceObject = require("langchain");
-const duckduckgo_search_namespaceObject = require("@langchain/community/tools/duckduckgo_search");
+const external_duck_duck_scrape_namespaceObject = require("duck-duck-scrape");
 const openai_namespaceObject = require("@langchain/openai");
 const external_zod_namespaceObject = require("zod");
 function _define_property(obj, key, value) {
@@ -103,13 +103,17 @@ const formatDdgError = (error, attempts)=>new Error(`DuckDuckGo search was rate-
         cause: error
     });
 async function runDuckDuckGoSearch(query, maxResults) {
-    const search = new duckduckgo_search_namespaceObject.DuckDuckGoSearch({
-        maxResults
-    });
     let attempt = 0;
     let delayMs = ddgBackoffBaseMs;
     while(true)try {
-        return await ddgRateLimiter.run(()=>search._call(query));
+        return await ddgRateLimiter.run(async ()=>{
+            const { results } = await (0, external_duck_duck_scrape_namespaceObject.search)(query);
+            return JSON.stringify(results.map((result)=>({
+                    title: result.title,
+                    link: result.url,
+                    snippet: result.description
+                })).slice(0, maxResults));
+        });
     } catch (error) {
         const shouldRetry = isDdgAnomalyError(error);
         if (!shouldRetry || attempt >= ddgMaxRetries) {

package/dist/agent/tools/internet_search.js

@@ -1,5 +1,5 @@
 import { tool } from "langchain";
-import { DuckDuckGoSearch } from "@langchain/community/tools/duckduckgo_search";
+import { search } from "duck-duck-scrape";
 import { ChatOpenAI } from "@langchain/openai";
 import { number, object, string } from "zod";
 function _define_property(obj, key, value) {
@@ -74,13 +74,17 @@ const formatDdgError = (error, attempts)=>new Error(`DuckDuckGo search was rate-
         cause: error
     });
 async function runDuckDuckGoSearch(query, maxResults) {
-    const search = new DuckDuckGoSearch({
-        maxResults
-    });
     let attempt = 0;
     let delayMs = ddgBackoffBaseMs;
     while(true)try {
-        return await ddgRateLimiter.run(()=>search._call(query));
+        return await ddgRateLimiter.run(async ()=>{
+            const { results } = await search(query);
+            return JSON.stringify(results.map((result)=>({
+                    title: result.title,
+                    link: result.url,
+                    snippet: result.description
+                })).slice(0, maxResults));
+        });
     } catch (error) {
         const shouldRetry = isDdgAnomalyError(error);
         if (!shouldRetry || attempt >= ddgMaxRetries) {

package/dist/cli/commands/skill.cjs

@@ -41,14 +41,17 @@ async function executeSkillCommand(args, options = {}) {
     const config = configLoader.loadConfig();
     try {
         const repository = new skillRepository_cjs_namespaceObject.SkillRepository({
+            provider: config.skills?.provider,
             repositoryOwner: config.skills?.repositoryOwner,
             repositoryName: config.skills?.repositoryName,
-            githubToken: config.skills?.githubToken
+            githubToken: config.skills?.githubToken,
+            clawhubBaseUrl: config.skills?.clawhubBaseUrl
         });
         const service = new skillService_cjs_namespaceObject.SkillService(repository, outputManager, logger, {
             workspace,
             skillsDirectory: config.skills?.skillsDirectory,
-            outputMode: args.outputMode
+            outputMode: args.outputMode,
+            security: config.skills?.security
         });
         const subcommand = args.subcommand;
         const subcommandArgs = args.args;
@@ -100,7 +103,7 @@ async function executeSkillCommand(args, options = {}) {
 }
 function showSkillHelp(outputManager) {
     if ("interactive" === outputManager.getMode()) console.log(`
-Wingman Skill Manager - Install skills from the Anthropic skills repository
+Wingman Skill Manager - Install skills from configured registries
 
 Usage:
   wingman skill browse              Browse available skills
@@ -123,10 +126,15 @@ Configuration:
   Skills can be configured in .wingman/wingman.config.json:
   {
     "skills": {
+      "provider": "github",
       "repositoryOwner": "anthropics",
       "repositoryName": "skills",
       "githubToken": "optional-token",
-      "skillsDirectory": "skills"
+      "clawhubBaseUrl": "https://clawhub.ai",
+      "skillsDirectory": "skills",
+      "security": {
+        "scanOnInstall": true
+      }
     }
   }
 `);