@wingman-ai/gateway 0.1.1 → 0.1.3

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

@@ -21,7 +21,14 @@ const skillsDir = "skills";
     (0, external_vitest_namespaceObject.it)("lists registry components", async ()=>{
         const tool = (0, ui_registry_cjs_namespaceObject.createUiRegistryListTool)(workspace, skillsDir);
         const result = await tool.invoke({});
-        (0, external_vitest_namespaceObject.expect)(result.components.some((component)=>"stat_grid" === component.id)).toBe(true);
+        const ids = result.components.map((component)=>component.id);
+        (0, external_vitest_namespaceObject.expect)(ids.includes("stat_grid")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(ids.includes("line_chart")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(ids.includes("area_chart")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(ids.includes("bar_chart")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(ids.includes("data_table")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(ids.includes("timeline")).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(ids.includes("status_list")).toBe(true);
     });
     (0, external_vitest_namespaceObject.it)("returns schema details for a registry component", async ()=>{
         const tool = (0, ui_registry_cjs_namespaceObject.createUiRegistryGetTool)(workspace, skillsDir);
@@ -31,6 +38,23 @@ const skillsDir = "skills";
         (0, external_vitest_namespaceObject.expect)(result.componentId).toBe("stat_grid");
         (0, external_vitest_namespaceObject.expect)(result.propsSchema).toBeTruthy();
     });
+    (0, external_vitest_namespaceObject.it)("returns schema details for new registry components", async ()=>{
+        const tool = (0, ui_registry_cjs_namespaceObject.createUiRegistryGetTool)(workspace, skillsDir);
+        for (const componentId of [
+            "line_chart",
+            "area_chart",
+            "bar_chart",
+            "data_table",
+            "timeline",
+            "status_list"
+        ]){
+            const result = await tool.invoke({
+                componentId
+            });
+            (0, external_vitest_namespaceObject.expect)(result.componentId).toBe(componentId);
+            (0, external_vitest_namespaceObject.expect)(result.propsSchema).toBeTruthy();
+        }
+    });
     (0, external_vitest_namespaceObject.it)("renders UI payload when enabled", async ()=>{
         const tool = (0, ui_registry_cjs_namespaceObject.createUiPresentTool)(workspace, skillsDir, true);
         const result = await tool.invoke({

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

@@ -16,7 +16,14 @@ describe("UI Registry Tools", ()=>{
     it("lists registry components", async ()=>{
         const tool = createUiRegistryListTool(workspace, skillsDir);
         const result = await tool.invoke({});
-        expect(result.components.some((component)=>"stat_grid" === component.id)).toBe(true);
+        const ids = result.components.map((component)=>component.id);
+        expect(ids.includes("stat_grid")).toBe(true);
+        expect(ids.includes("line_chart")).toBe(true);
+        expect(ids.includes("area_chart")).toBe(true);
+        expect(ids.includes("bar_chart")).toBe(true);
+        expect(ids.includes("data_table")).toBe(true);
+        expect(ids.includes("timeline")).toBe(true);
+        expect(ids.includes("status_list")).toBe(true);
     });
     it("returns schema details for a registry component", async ()=>{
         const tool = createUiRegistryGetTool(workspace, skillsDir);
@@ -26,6 +33,23 @@ describe("UI Registry Tools", ()=>{
         expect(result.componentId).toBe("stat_grid");
         expect(result.propsSchema).toBeTruthy();
     });
+    it("returns schema details for new registry components", async ()=>{
+        const tool = createUiRegistryGetTool(workspace, skillsDir);
+        for (const componentId of [
+            "line_chart",
+            "area_chart",
+            "bar_chart",
+            "data_table",
+            "timeline",
+            "status_list"
+        ]){
+            const result = await tool.invoke({
+                componentId
+            });
+            expect(result.componentId).toBe(componentId);
+            expect(result.propsSchema).toBeTruthy();
+        }
+    });
     it("renders UI payload when enabled", async ()=>{
         const tool = createUiPresentTool(workspace, skillsDir, true);
         const result = await tool.invoke({

package/dist/cli/config/loader.cjs

@@ -29,6 +29,7 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
 const external_schema_cjs_namespaceObject = require("./schema.cjs");
+const external_warnings_cjs_namespaceObject = require("./warnings.cjs");
 const env_cjs_namespaceObject = require("../../gateway/env.cjs");
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
 function _define_property(obj, key, value) {
@@ -46,7 +47,9 @@ class WingmanConfigLoader {
         const configPath = (0, external_node_path_namespaceObject.join)(this.workspace, this.configDir, "wingman.config.json");
         if (!(0, external_node_fs_namespaceObject.existsSync)(configPath)) {
             this.logger.info(`Config file not found at ${configPath}, using default configuration`);
-            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            const finalConfig = this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            this.logConfigWarnings(finalConfig);
+            return finalConfig;
         }
         try {
             const content = (0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8");
@@ -58,12 +61,16 @@ class WingmanConfigLoader {
                 return this.getDefaultConfig();
             }
             this.logger.debug(`Loaded configuration from ${configPath} with values: ${JSON.stringify(validation.data)}`);
-            return this.applyGatewayAuthEnvOverrides(validation.data);
+            const finalConfig = this.applyGatewayAuthEnvOverrides(validation.data);
+            this.logConfigWarnings(finalConfig);
+            return finalConfig;
         } catch (error) {
             if (error instanceof SyntaxError) this.logger.error(`Warning: Invalid JSON in ${configPath}: ${error.message}`);
             else this.logger.error(`Warning: Failed to load config: ${error}`);
             this.logger.error("Using default configuration");
-            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            const finalConfig = this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            this.logConfigWarnings(finalConfig);
+            return finalConfig;
         }
     }
     applyGatewayAuthEnvOverrides(config) {
@@ -126,6 +133,10 @@ class WingmanConfigLoader {
             }
         };
     }
+    logConfigWarnings(config) {
+        const warnings = (0, external_warnings_cjs_namespaceObject.collectConfigWarnings)(config);
+        for (const warning of warnings)this.logger.warn(`Config warning: ${warning.message}`);
+    }
     constructor(configDir = ".wingman", workspace = process.cwd()){
         _define_property(this, "configDir", void 0);
         _define_property(this, "workspace", void 0);

package/dist/cli/config/loader.d.ts

@@ -11,4 +11,5 @@ export declare class WingmanConfigLoader {
     loadConfig(): WingmanConfigType;
     private applyGatewayAuthEnvOverrides;
     private getDefaultConfig;
+    private logConfigWarnings;
 }

package/dist/cli/config/loader.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { validateConfig } from "./schema.js";
+import { collectConfigWarnings } from "./warnings.js";
 import { getGatewayTokenFromEnv } from "../../gateway/env.js";
 import { createLogger } from "../../logger.js";
 function _define_property(obj, key, value) {
@@ -18,7 +19,9 @@ class WingmanConfigLoader {
         const configPath = join(this.workspace, this.configDir, "wingman.config.json");
         if (!existsSync(configPath)) {
             this.logger.info(`Config file not found at ${configPath}, using default configuration`);
-            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            const finalConfig = this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            this.logConfigWarnings(finalConfig);
+            return finalConfig;
         }
         try {
             const content = readFileSync(configPath, "utf-8");
@@ -30,12 +33,16 @@ class WingmanConfigLoader {
                 return this.getDefaultConfig();
             }
             this.logger.debug(`Loaded configuration from ${configPath} with values: ${JSON.stringify(validation.data)}`);
-            return this.applyGatewayAuthEnvOverrides(validation.data);
+            const finalConfig = this.applyGatewayAuthEnvOverrides(validation.data);
+            this.logConfigWarnings(finalConfig);
+            return finalConfig;
         } catch (error) {
             if (error instanceof SyntaxError) this.logger.error(`Warning: Invalid JSON in ${configPath}: ${error.message}`);
             else this.logger.error(`Warning: Failed to load config: ${error}`);
             this.logger.error("Using default configuration");
-            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            const finalConfig = this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+            this.logConfigWarnings(finalConfig);
+            return finalConfig;
         }
     }
     applyGatewayAuthEnvOverrides(config) {
@@ -98,6 +105,10 @@ class WingmanConfigLoader {
             }
         };
     }
+    logConfigWarnings(config) {
+        const warnings = collectConfigWarnings(config);
+        for (const warning of warnings)this.logger.warn(`Config warning: ${warning.message}`);
+    }
     constructor(configDir = ".wingman", workspace = process.cwd()){
         _define_property(this, "configDir", void 0);
         _define_property(this, "workspace", void 0);

package/dist/cli/config/warnings.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    collectConfigWarnings: ()=>collectConfigWarnings
+});
+const AGENT_PREFIX = /^agent:[^:]+:/;
+const hasLeadingOrTrailingWhitespace = (value)=>value.trim() !== value;
+const isBlank = (value)=>0 === value.trim().length;
+function collectConfigWarnings(config) {
+    const warnings = [];
+    const discord = config.gateway?.adapters?.discord;
+    if (!discord?.enabled) return warnings;
+    if (!discord.token) warnings.push({
+        code: "discord-token-missing",
+        message: "gateway.adapters.discord.enabled is true but gateway.adapters.discord.token is not set; the adapter will not start."
+    });
+    if (isBlank(discord.sessionCommand || "")) warnings.push({
+        code: "discord-session-command-blank",
+        message: 'gateway.adapters.discord.sessionCommand is blank; it will fall back to "!session".'
+    });
+    for (const [rawKey, rawValue] of Object.entries(discord.channelSessions ?? {})){
+        const keyLabel = JSON.stringify(rawKey);
+        const value = "string" == typeof rawValue ? rawValue : "";
+        const valueLabel = JSON.stringify(value);
+        if (hasLeadingOrTrailingWhitespace(rawKey)) warnings.push({
+            code: "discord-channel-sessions-key-whitespace",
+            message: `gateway.adapters.discord.channelSessions key ${keyLabel} has leading/trailing whitespace.`
+        });
+        if (hasLeadingOrTrailingWhitespace(value)) warnings.push({
+            code: "discord-channel-sessions-value-whitespace",
+            message: `gateway.adapters.discord.channelSessions[${keyLabel}] value ${valueLabel} has leading/trailing whitespace.`
+        });
+        if (isBlank(value)) {
+            warnings.push({
+                code: "discord-channel-sessions-value-blank",
+                message: `gateway.adapters.discord.channelSessions[${keyLabel}] is empty; mapping will fall back to derived session keys.`
+            });
+            continue;
+        }
+        if (!AGENT_PREFIX.test(value.trim())) warnings.push({
+            code: "discord-channel-sessions-missing-agent",
+            message: `gateway.adapters.discord.channelSessions[${keyLabel}] does not include an agent prefix (agent:<id>:...); agent selection will use bindings/default.`
+        });
+    }
+    for (const entry of discord.allowedChannels ?? []){
+        const label = JSON.stringify(entry);
+        if (isBlank(entry)) {
+            warnings.push({
+                code: "discord-allowed-channels-blank",
+                message: "gateway.adapters.discord.allowedChannels contains a blank entry; remove empty strings."
+            });
+            continue;
+        }
+        if (hasLeadingOrTrailingWhitespace(entry)) warnings.push({
+            code: "discord-allowed-channels-whitespace",
+            message: `gateway.adapters.discord.allowedChannels contains ${label} with leading/trailing whitespace.`
+        });
+    }
+    for (const entry of discord.allowedGuilds ?? []){
+        const label = JSON.stringify(entry);
+        if (isBlank(entry)) {
+            warnings.push({
+                code: "discord-allowed-guilds-blank",
+                message: "gateway.adapters.discord.allowedGuilds contains a blank entry; remove empty strings."
+            });
+            continue;
+        }
+        if (hasLeadingOrTrailingWhitespace(entry)) warnings.push({
+            code: "discord-allowed-guilds-whitespace",
+            message: `gateway.adapters.discord.allowedGuilds contains ${label} with leading/trailing whitespace.`
+        });
+    }
+    return warnings;
+}
+exports.collectConfigWarnings = __webpack_exports__.collectConfigWarnings;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectConfigWarnings"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/config/warnings.d.ts

@@ -0,0 +1,6 @@
+import type { WingmanConfigType } from "./schema.js";
+export type ConfigWarning = {
+    code: string;
+    message: string;
+};
+export declare function collectConfigWarnings(config: WingmanConfigType): ConfigWarning[];

package/dist/cli/config/warnings.js

@@ -0,0 +1,70 @@
+const AGENT_PREFIX = /^agent:[^:]+:/;
+const hasLeadingOrTrailingWhitespace = (value)=>value.trim() !== value;
+const isBlank = (value)=>0 === value.trim().length;
+function collectConfigWarnings(config) {
+    const warnings = [];
+    const discord = config.gateway?.adapters?.discord;
+    if (!discord?.enabled) return warnings;
+    if (!discord.token) warnings.push({
+        code: "discord-token-missing",
+        message: "gateway.adapters.discord.enabled is true but gateway.adapters.discord.token is not set; the adapter will not start."
+    });
+    if (isBlank(discord.sessionCommand || "")) warnings.push({
+        code: "discord-session-command-blank",
+        message: 'gateway.adapters.discord.sessionCommand is blank; it will fall back to "!session".'
+    });
+    for (const [rawKey, rawValue] of Object.entries(discord.channelSessions ?? {})){
+        const keyLabel = JSON.stringify(rawKey);
+        const value = "string" == typeof rawValue ? rawValue : "";
+        const valueLabel = JSON.stringify(value);
+        if (hasLeadingOrTrailingWhitespace(rawKey)) warnings.push({
+            code: "discord-channel-sessions-key-whitespace",
+            message: `gateway.adapters.discord.channelSessions key ${keyLabel} has leading/trailing whitespace.`
+        });
+        if (hasLeadingOrTrailingWhitespace(value)) warnings.push({
+            code: "discord-channel-sessions-value-whitespace",
+            message: `gateway.adapters.discord.channelSessions[${keyLabel}] value ${valueLabel} has leading/trailing whitespace.`
+        });
+        if (isBlank(value)) {
+            warnings.push({
+                code: "discord-channel-sessions-value-blank",
+                message: `gateway.adapters.discord.channelSessions[${keyLabel}] is empty; mapping will fall back to derived session keys.`
+            });
+            continue;
+        }
+        if (!AGENT_PREFIX.test(value.trim())) warnings.push({
+            code: "discord-channel-sessions-missing-agent",
+            message: `gateway.adapters.discord.channelSessions[${keyLabel}] does not include an agent prefix (agent:<id>:...); agent selection will use bindings/default.`
+        });
+    }
+    for (const entry of discord.allowedChannels ?? []){
+        const label = JSON.stringify(entry);
+        if (isBlank(entry)) {
+            warnings.push({
+                code: "discord-allowed-channels-blank",
+                message: "gateway.adapters.discord.allowedChannels contains a blank entry; remove empty strings."
+            });
+            continue;
+        }
+        if (hasLeadingOrTrailingWhitespace(entry)) warnings.push({
+            code: "discord-allowed-channels-whitespace",
+            message: `gateway.adapters.discord.allowedChannels contains ${label} with leading/trailing whitespace.`
+        });
+    }
+    for (const entry of discord.allowedGuilds ?? []){
+        const label = JSON.stringify(entry);
+        if (isBlank(entry)) {
+            warnings.push({
+                code: "discord-allowed-guilds-blank",
+                message: "gateway.adapters.discord.allowedGuilds contains a blank entry; remove empty strings."
+            });
+            continue;
+        }
+        if (hasLeadingOrTrailingWhitespace(entry)) warnings.push({
+            code: "discord-allowed-guilds-whitespace",
+            message: `gateway.adapters.discord.allowedGuilds contains ${label} with leading/trailing whitespace.`
+        });
+    }
+    return warnings;
+}
+export { collectConfigWarnings };

package/dist/cli/core/agentInvoker.cjs

@@ -128,9 +128,7 @@ class AgentInvoker {
                     }), backendOverrides),
                 middleware: middleware,
                 skills: skillsSources,
-                subagents: [
-                    ...targetAgent.subagents || []
-                ],
+                subagents: targetAgent.subagents || [],
                 checkpointer: checkpointer
             });
             this.logger.debug("Agent created, sending message");

package/dist/cli/core/agentInvoker.js

@@ -99,9 +99,7 @@ class AgentInvoker {
                     }), backendOverrides),
                 middleware: middleware,
                 skills: skillsSources,
-                subagents: [
-                    ...targetAgent.subagents || []
-                ],
+                subagents: targetAgent.subagents || [],
                 checkpointer: checkpointer
             });
             this.logger.debug("Agent created, sending message");

package/dist/gateway/index.cjs

@@ -91,9 +91,9 @@ var __webpack_exports__ = {};
         "GatewayDaemon",
         "default",
         "NodeManager",
-        "GatewayRpcClient",
-        "BroadcastGroupManager",
         "GatewayAuth",
+        "BroadcastGroupManager",
+        "GatewayRpcClient",
         "GatewayServer"
     ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_js__rspack_import_7[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);

package/dist/tests/cli-config-warnings.test.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const schema_cjs_namespaceObject = require("../cli/config/schema.cjs");
+const warnings_cjs_namespaceObject = require("../cli/config/warnings.cjs");
+(0, external_vitest_namespaceObject.describe)("Config warnings", ()=>{
+    (0, external_vitest_namespaceObject.it)("returns warnings for common Discord config issues", ()=>{
+        const base = (0, schema_cjs_namespaceObject.validateConfig)({}).data;
+        const config = {
+            ...base,
+            gateway: {
+                ...base.gateway,
+                adapters: {
+                    ...base.gateway.adapters,
+                    discord: {
+                        enabled: true,
+                        token: void 0,
+                        mentionOnly: true,
+                        allowBots: false,
+                        allowedGuilds: [
+                            " "
+                        ],
+                        allowedChannels: [
+                            "",
+                            " 123 "
+                        ],
+                        channelSessions: {
+                            " 123 ": " session-plain ",
+                            456: "session-plain"
+                        },
+                        sessionCommand: " ",
+                        responseChunkSize: 1900
+                    }
+                }
+            }
+        };
+        const warnings = (0, warnings_cjs_namespaceObject.collectConfigWarnings)(config).map((warning)=>warning.message);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("token"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("sessionCommand"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("channelSessions"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("agent prefix"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("allowedChannels"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("allowedGuilds"))).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("returns no warnings when Discord adapter is disabled", ()=>{
+        const base = (0, schema_cjs_namespaceObject.validateConfig)({}).data;
+        (0, external_vitest_namespaceObject.expect)((0, warnings_cjs_namespaceObject.collectConfigWarnings)(base)).toEqual([]);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/cli-config-warnings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cli-config-warnings.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { validateConfig } from "../cli/config/schema.js";
+import { collectConfigWarnings } from "../cli/config/warnings.js";
+describe("Config warnings", ()=>{
+    it("returns warnings for common Discord config issues", ()=>{
+        const base = validateConfig({}).data;
+        const config = {
+            ...base,
+            gateway: {
+                ...base.gateway,
+                adapters: {
+                    ...base.gateway.adapters,
+                    discord: {
+                        enabled: true,
+                        token: void 0,
+                        mentionOnly: true,
+                        allowBots: false,
+                        allowedGuilds: [
+                            " "
+                        ],
+                        allowedChannels: [
+                            "",
+                            " 123 "
+                        ],
+                        channelSessions: {
+                            " 123 ": " session-plain ",
+                            456: "session-plain"
+                        },
+                        sessionCommand: " ",
+                        responseChunkSize: 1900
+                    }
+                }
+            }
+        };
+        const warnings = collectConfigWarnings(config).map((warning)=>warning.message);
+        expect(warnings.some((msg)=>msg.includes("token"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("sessionCommand"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("channelSessions"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("agent prefix"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("allowedChannels"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("allowedGuilds"))).toBe(true);
+    });
+    it("returns no warnings when Discord adapter is disabled", ()=>{
+        const base = validateConfig({}).data;
+        expect(collectConfigWarnings(base)).toEqual([]);
+    });
+});

package/dist/types/agents.d.ts

@@ -1,8 +1,19 @@
-import type { createDeepAgent } from "deepagents";
 import type { HooksConfig } from "./hooks.js";
 import type { MCPServersConfig } from "./mcp.js";
 import type { AgentVoiceConfig } from "./voice.js";
-export type WingmanAgent = Pick<NonNullable<Parameters<typeof createDeepAgent>[0]>, "name" | "systemPrompt" | "tools" | "skills" | "model" | "subagents"> & {
+export type WingmanAgentTool = {
+    name: string;
+    description?: string;
+    schema?: unknown;
+    invoke?: (...args: any[]) => unknown;
+};
+export type WingmanAgent = {
+    name: string;
+    systemPrompt: string;
+    tools?: WingmanAgentTool[];
+    skills?: string[];
+    model?: unknown;
+    subagents?: WingmanAgent[];
     description?: string;
     toolHooks?: HooksConfig;
     mcpConfig?: MCPServersConfig;