@wingman-ai/gateway 0.1.0

package/dist/agent/middleware/hooks/merger.cjs

@@ -0,0 +1,54 @@
+"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__, {
+    mergeHooks: ()=>mergeHooks
+});
+function mergeHooks(globalHooks, agentHooks) {
+    if (!globalHooks && !agentHooks) return;
+    if (!globalHooks) return agentHooks;
+    if (!agentHooks) return globalHooks;
+    const merged = {};
+    if (globalHooks.PreToolUse || agentHooks.PreToolUse) merged.PreToolUse = [
+        ...globalHooks.PreToolUse || [],
+        ...agentHooks.PreToolUse || []
+    ];
+    if (globalHooks.PostToolUse || agentHooks.PostToolUse) merged.PostToolUse = [
+        ...globalHooks.PostToolUse || [],
+        ...agentHooks.PostToolUse || []
+    ];
+    if (globalHooks.Stop || agentHooks.Stop) merged.Stop = [
+        ...globalHooks.Stop || [],
+        ...agentHooks.Stop || []
+    ];
+    return merged;
+}
+exports.mergeHooks = __webpack_exports__.mergeHooks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mergeHooks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/hooks/merger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hook Configuration Merger
+ *
+ * Merges global and agent-specific hook configurations
+ */
+import type { HooksConfig } from "@/types/hooks.js";
+/**
+ * Merge global and agent-specific hooks configurations
+ *
+ * Both global and agent hooks are executed. Hooks from both sources are concatenated
+ * for each event type. No deduplication is performed - if the same hook is defined
+ * in both places, it will run twice.
+ *
+ * @param globalHooks - Hooks from wingman.config.json
+ * @param agentHooks - Hooks from agent.json
+ * @returns Merged hooks configuration
+ */
+export declare function mergeHooks(globalHooks: HooksConfig | undefined, agentHooks: HooksConfig | undefined): HooksConfig | undefined;

package/dist/agent/middleware/hooks/merger.js

@@ -0,0 +1,20 @@
+function mergeHooks(globalHooks, agentHooks) {
+    if (!globalHooks && !agentHooks) return;
+    if (!globalHooks) return agentHooks;
+    if (!agentHooks) return globalHooks;
+    const merged = {};
+    if (globalHooks.PreToolUse || agentHooks.PreToolUse) merged.PreToolUse = [
+        ...globalHooks.PreToolUse || [],
+        ...agentHooks.PreToolUse || []
+    ];
+    if (globalHooks.PostToolUse || agentHooks.PostToolUse) merged.PostToolUse = [
+        ...globalHooks.PostToolUse || [],
+        ...agentHooks.PostToolUse || []
+    ];
+    if (globalHooks.Stop || agentHooks.Stop) merged.Stop = [
+        ...globalHooks.Stop || [],
+        ...agentHooks.Stop || []
+    ];
+    return merged;
+}
+export { mergeHooks };

package/dist/agent/middleware/hooks/types.cjs

@@ -0,0 +1,62 @@
+"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__, {
+    HookSchema: ()=>HookSchema,
+    StopHookSchema: ()=>StopHookSchema,
+    HookMatcherSchema: ()=>HookMatcherSchema,
+    HooksConfigSchema: ()=>HooksConfigSchema
+});
+const external_zod_namespaceObject = require("zod");
+const HookSchema = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.literal("command").describe("Type of hook - currently only 'command' is supported"),
+    command: external_zod_namespaceObject.z.string().min(1).describe("Shell command to execute"),
+    timeout: external_zod_namespaceObject.z.number().positive().optional().default(60).describe("Timeout in seconds (default: 60)")
+});
+const HookMatcherSchema = external_zod_namespaceObject.z.object({
+    matcher: external_zod_namespaceObject.z.string().optional().describe("Pattern to match tool names (pipe-separated, wildcard, or regex)"),
+    hooks: external_zod_namespaceObject.z.array(HookSchema).min(1).describe("Array of hooks to execute when pattern matches")
+});
+const StopHookSchema = external_zod_namespaceObject.z.object({
+    hooks: external_zod_namespaceObject.z.array(HookSchema).min(1).describe("Array of hooks to execute when agent stops")
+});
+const HooksConfigSchema = external_zod_namespaceObject.z.object({
+    PreToolUse: external_zod_namespaceObject.z.array(HookMatcherSchema).optional().describe("Hooks that fire before tool execution (can block)"),
+    PostToolUse: external_zod_namespaceObject.z.array(HookMatcherSchema).optional().describe("Hooks that fire after tool completes (non-blocking)"),
+    Stop: external_zod_namespaceObject.z.array(StopHookSchema).optional().describe("Hooks that fire when agent completes (non-blocking)")
+});
+exports.HookMatcherSchema = __webpack_exports__.HookMatcherSchema;
+exports.HookSchema = __webpack_exports__.HookSchema;
+exports.HooksConfigSchema = __webpack_exports__.HooksConfigSchema;
+exports.StopHookSchema = __webpack_exports__.StopHookSchema;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HookMatcherSchema",
+    "HookSchema",
+    "HooksConfigSchema",
+    "StopHookSchema"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/hooks/types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Internal Hooks Types and Zod Schemas
+ *
+ * Validation schemas for hook configurations and runtime execution context
+ */
+import { z } from "zod";
+import type { ToolCallRequest, ToolMessage } from "langchain";
+/**
+ * Zod schema for individual hook configuration
+ */
+export declare const HookSchema: z.ZodObject<{
+    type: z.ZodLiteral<"command">;
+    command: z.ZodString;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for hook matcher (PreToolUse, PostToolUse)
+ */
+export declare const HookMatcherSchema: z.ZodObject<{
+    matcher: z.ZodOptional<z.ZodString>;
+    hooks: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"command">;
+        command: z.ZodString;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for Stop hooks (no matcher)
+ */
+export declare const StopHookSchema: z.ZodObject<{
+    hooks: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"command">;
+        command: z.ZodString;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for complete hooks configuration
+ */
+export declare const HooksConfigSchema: z.ZodObject<{
+    PreToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        matcher: z.ZodOptional<z.ZodString>;
+        hooks: z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"command">;
+            command: z.ZodString;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    PostToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        matcher: z.ZodOptional<z.ZodString>;
+        hooks: z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"command">;
+            command: z.ZodString;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    Stop: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        hooks: z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"command">;
+            command: z.ZodString;
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Hook event names
+ */
+export type HookEventName = "PreToolUse" | "PostToolUse" | "Stop";
+/**
+ * Runtime context for hook execution
+ * Contains all data needed to execute hooks for a specific event
+ */
+export interface HookExecutionContext {
+    /** Unique session identifier */
+    sessionId: string;
+    /** Current working directory */
+    cwd: string;
+    /** Tool call request (for PreToolUse/PostToolUse) */
+    toolCallRequest?: ToolCallRequest;
+    /** Tool result (for PostToolUse only) */
+    toolResult?: ToolMessage;
+}

package/dist/agent/middleware/hooks/types.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+const HookSchema = z.object({
+    type: z.literal("command").describe("Type of hook - currently only 'command' is supported"),
+    command: z.string().min(1).describe("Shell command to execute"),
+    timeout: z.number().positive().optional().default(60).describe("Timeout in seconds (default: 60)")
+});
+const HookMatcherSchema = z.object({
+    matcher: z.string().optional().describe("Pattern to match tool names (pipe-separated, wildcard, or regex)"),
+    hooks: z.array(HookSchema).min(1).describe("Array of hooks to execute when pattern matches")
+});
+const StopHookSchema = z.object({
+    hooks: z.array(HookSchema).min(1).describe("Array of hooks to execute when agent stops")
+});
+const HooksConfigSchema = z.object({
+    PreToolUse: z.array(HookMatcherSchema).optional().describe("Hooks that fire before tool execution (can block)"),
+    PostToolUse: z.array(HookMatcherSchema).optional().describe("Hooks that fire after tool completes (non-blocking)"),
+    Stop: z.array(StopHookSchema).optional().describe("Hooks that fire when agent completes (non-blocking)")
+});
+export { HookMatcherSchema, HookSchema, HooksConfigSchema, StopHookSchema };

package/dist/agent/middleware/hooks.cjs

@@ -0,0 +1,79 @@
+"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__, {
+    createHooksMiddleware: ()=>createHooksMiddleware
+});
+const external_langchain_namespaceObject = require("langchain");
+const executor_cjs_namespaceObject = require("./hooks/executor.cjs");
+function createHooksMiddleware(hooksConfig, workspace, sessionId, logger) {
+    const executor = new executor_cjs_namespaceObject.HookExecutor(workspace, logger);
+    return {
+        name: "hooks-middleware",
+        [external_langchain_namespaceObject.MIDDLEWARE_BRAND]: true,
+        wrapToolCall: async (request, handler)=>{
+            const context = {
+                sessionId,
+                cwd: workspace,
+                toolCallRequest: request
+            };
+            if (hooksConfig.PreToolUse && hooksConfig.PreToolUse.length > 0) try {
+                await executor.executeHooksForEvent("PreToolUse", hooksConfig.PreToolUse, context, true);
+            } catch (error) {
+                logger.error(`PreToolUse hook blocked tool execution: ${error instanceof Error ? error.message : String(error)}`);
+                throw error;
+            }
+            const result = await handler(request);
+            if (hooksConfig.PostToolUse && hooksConfig.PostToolUse.length > 0 && "content" in result) {
+                const postContext = {
+                    ...context,
+                    toolResult: result
+                };
+                executor.executeHooksForEvent("PostToolUse", hooksConfig.PostToolUse, postContext, false).catch((error)=>{
+                    logger.warn(`PostToolUse hook failed (non-blocking): ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+            return result;
+        },
+        afterAgent: async ()=>{
+            if (hooksConfig.Stop && hooksConfig.Stop.length > 0) {
+                const context = {
+                    sessionId,
+                    cwd: workspace
+                };
+                executor.executeStopHooks(hooksConfig.Stop, context).catch((error)=>{
+                    logger.warn(`Stop hook failed (non-blocking): ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+        }
+    };
+}
+exports.createHooksMiddleware = __webpack_exports__.createHooksMiddleware;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHooksMiddleware"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/hooks.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hooks Middleware
+ *
+ * Integrates with deepagent's middleware system to execute user-defined hooks
+ * at specific lifecycle points (PreToolUse, PostToolUse, Stop)
+ */
+import { type AgentMiddleware } from "langchain";
+import type { HooksConfig } from "@/types/hooks.js";
+import type { Logger } from "@/logger.js";
+/**
+ * Create hooks middleware for deepagent
+ *
+ * @param hooksConfig - Merged hooks configuration (global + agent-specific)
+ * @param workspace - Workspace directory path
+ * @param sessionId - Unique session identifier
+ * @param logger - Logger instance
+ * @returns AgentMiddleware instance
+ */
+export declare function createHooksMiddleware(hooksConfig: HooksConfig, workspace: string, sessionId: string, logger: Logger): AgentMiddleware;

package/dist/agent/middleware/hooks.js

@@ -0,0 +1,45 @@
+import { MIDDLEWARE_BRAND } from "langchain";
+import { HookExecutor } from "./hooks/executor.js";
+function createHooksMiddleware(hooksConfig, workspace, sessionId, logger) {
+    const executor = new HookExecutor(workspace, logger);
+    return {
+        name: "hooks-middleware",
+        [MIDDLEWARE_BRAND]: true,
+        wrapToolCall: async (request, handler)=>{
+            const context = {
+                sessionId,
+                cwd: workspace,
+                toolCallRequest: request
+            };
+            if (hooksConfig.PreToolUse && hooksConfig.PreToolUse.length > 0) try {
+                await executor.executeHooksForEvent("PreToolUse", hooksConfig.PreToolUse, context, true);
+            } catch (error) {
+                logger.error(`PreToolUse hook blocked tool execution: ${error instanceof Error ? error.message : String(error)}`);
+                throw error;
+            }
+            const result = await handler(request);
+            if (hooksConfig.PostToolUse && hooksConfig.PostToolUse.length > 0 && "content" in result) {
+                const postContext = {
+                    ...context,
+                    toolResult: result
+                };
+                executor.executeHooksForEvent("PostToolUse", hooksConfig.PostToolUse, postContext, false).catch((error)=>{
+                    logger.warn(`PostToolUse hook failed (non-blocking): ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+            return result;
+        },
+        afterAgent: async ()=>{
+            if (hooksConfig.Stop && hooksConfig.Stop.length > 0) {
+                const context = {
+                    sessionId,
+                    cwd: workspace
+                };
+                executor.executeStopHooks(hooksConfig.Stop, context).catch((error)=>{
+                    logger.warn(`Stop hook failed (non-blocking): ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+        }
+    };
+}
+export { createHooksMiddleware };

package/dist/agent/middleware/media-compat.cjs

@@ -0,0 +1,80 @@
+"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__, {
+    mediaCompatibilityMiddleware: ()=>mediaCompatibilityMiddleware
+});
+const anthropic_namespaceObject = require("@langchain/anthropic");
+const external_langchain_namespaceObject = require("langchain");
+const DEFAULT_AUDIO_PLACEHOLDER = "[Audio omitted: current model does not support audio inputs]";
+const mediaCompatibilityMiddleware = (options = {})=>({
+        name: "media-compat-middleware",
+        [external_langchain_namespaceObject.MIDDLEWARE_BRAND]: true,
+        beforeAgent: async (input)=>{
+            if (!shouldStripAudio(options.model)) return input;
+            let mutated = false;
+            for (const message of input.messages){
+                const content = message.content;
+                if (!Array.isArray(content)) continue;
+                const { cleaned, removed } = stripAudioBlocks(content);
+                if (removed) {
+                    mutated = true;
+                    message.content = cleaned.length > 0 ? cleaned : options.audioPlaceholder || DEFAULT_AUDIO_PLACEHOLDER;
+                }
+            }
+            return mutated ? {
+                messages: input.messages
+            } : input;
+        }
+    });
+function shouldStripAudio(model) {
+    if (!model || "object" != typeof model) return false;
+    if (model instanceof anthropic_namespaceObject.ChatAnthropic) return true;
+    const ctorName = model?.constructor?.name;
+    return "string" == typeof ctorName && "chatanthropic" === ctorName.toLowerCase();
+}
+function stripAudioBlocks(blocks) {
+    let removed = false;
+    const cleaned = blocks.filter((block)=>{
+        if (!block || "object" != typeof block) return true;
+        const type = "string" == typeof block.type ? block.type.toLowerCase() : "";
+        if ("audio" === type || "audio_url" === type || "input_audio" === type) {
+            removed = true;
+            return false;
+        }
+        return true;
+    });
+    return {
+        cleaned,
+        removed
+    };
+}
+exports.mediaCompatibilityMiddleware = __webpack_exports__.mediaCompatibilityMiddleware;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mediaCompatibilityMiddleware"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/media-compat.d.ts

@@ -0,0 +1,7 @@
+import { type AgentMiddleware } from "langchain";
+type MediaCompatibilityOptions = {
+    model?: unknown;
+    audioPlaceholder?: string;
+};
+export declare const mediaCompatibilityMiddleware: (options?: MediaCompatibilityOptions) => AgentMiddleware;
+export {};

package/dist/agent/middleware/media-compat.js

@@ -0,0 +1,46 @@
+import { ChatAnthropic } from "@langchain/anthropic";
+import { MIDDLEWARE_BRAND } from "langchain";
+const DEFAULT_AUDIO_PLACEHOLDER = "[Audio omitted: current model does not support audio inputs]";
+const mediaCompatibilityMiddleware = (options = {})=>({
+        name: "media-compat-middleware",
+        [MIDDLEWARE_BRAND]: true,
+        beforeAgent: async (input)=>{
+            if (!shouldStripAudio(options.model)) return input;
+            let mutated = false;
+            for (const message of input.messages){
+                const content = message.content;
+                if (!Array.isArray(content)) continue;
+                const { cleaned, removed } = stripAudioBlocks(content);
+                if (removed) {
+                    mutated = true;
+                    message.content = cleaned.length > 0 ? cleaned : options.audioPlaceholder || DEFAULT_AUDIO_PLACEHOLDER;
+                }
+            }
+            return mutated ? {
+                messages: input.messages
+            } : input;
+        }
+    });
+function shouldStripAudio(model) {
+    if (!model || "object" != typeof model) return false;
+    if (model instanceof ChatAnthropic) return true;
+    const ctorName = model?.constructor?.name;
+    return "string" == typeof ctorName && "chatanthropic" === ctorName.toLowerCase();
+}
+function stripAudioBlocks(blocks) {
+    let removed = false;
+    const cleaned = blocks.filter((block)=>{
+        if (!block || "object" != typeof block) return true;
+        const type = "string" == typeof block.type ? block.type.toLowerCase() : "";
+        if ("audio" === type || "audio_url" === type || "input_audio" === type) {
+            removed = true;
+            return false;
+        }
+        return true;
+    });
+    return {
+        cleaned,
+        removed
+    };
+}
+export { mediaCompatibilityMiddleware };

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

@@ -0,0 +1,132 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const agentConfig_cjs_namespaceObject = require("../config/agentConfig.cjs");
+(0, external_vitest_namespaceObject.describe)("Agent Configuration Schema", ()=>{
+    (0, external_vitest_namespaceObject.describe)("validateAgentConfig", ()=>{
+        (0, external_vitest_namespaceObject.it)("should validate a valid minimal agent config", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "A test agent",
+                systemPrompt: "You are a test agent"
+            };
+            const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
+            (0, external_vitest_namespaceObject.expect)(result.success).toBe(true);
+            if (result.success) {
+                (0, external_vitest_namespaceObject.expect)(result.data.name).toBe("test-agent");
+                (0, external_vitest_namespaceObject.expect)(result.data.description).toBe("A test agent");
+                (0, external_vitest_namespaceObject.expect)(result.data.systemPrompt).toBe("You are a test agent");
+            }
+        });
+        (0, external_vitest_namespaceObject.it)("should validate a complete agent config with all fields", ()=>{
+            const config = {
+                name: "data-analyst",
+                description: "Analyzes data",
+                systemPrompt: "You are a data analyst",
+                tools: [
+                    "command_execute",
+                    "think"
+                ],
+                model: "anthropic:claude-opus-4-5",
+                blockedCommands: [
+                    "rm",
+                    "mv"
+                ],
+                allowScriptExecution: true,
+                commandTimeout: 300000
+            };
+            const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
+            (0, external_vitest_namespaceObject.expect)(result.success).toBe(true);
+            if (result.success) {
+                (0, external_vitest_namespaceObject.expect)(result.data.tools).toEqual([
+                    "command_execute",
+                    "think"
+                ]);
+                (0, external_vitest_namespaceObject.expect)(result.data.model).toBe("anthropic:claude-opus-4-5");
+                (0, external_vitest_namespaceObject.expect)(result.data.blockedCommands).toEqual([
+                    "rm",
+                    "mv"
+                ]);
+                (0, external_vitest_namespaceObject.expect)(result.data.allowScriptExecution).toBe(true);
+                (0, external_vitest_namespaceObject.expect)(result.data.commandTimeout).toBe(300000);
+            }
+        });
+        (0, external_vitest_namespaceObject.it)("should allow subagents to override models", ()=>{
+            const config = {
+                name: "parent-agent",
+                description: "Parent agent",
+                systemPrompt: "You are the parent agent",
+                subAgents: [
+                    {
+                        name: "research-agent",
+                        description: "Researches topics",
+                        systemPrompt: "You are a researcher",
+                        model: "openai:gpt-4o"
+                    }
+                ]
+            };
+            const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
+            (0, external_vitest_namespaceObject.expect)(result.success).toBe(true);
+            if (result.success) (0, external_vitest_namespaceObject.expect)(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
+        });
+        (0, external_vitest_namespaceObject.it)("should fail validation for missing required fields", ()=>{
+            const config = {
+                name: "test-agent"
+            };
+            const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
+            (0, external_vitest_namespaceObject.expect)(result.success).toBe(false);
+            if (!result.success) {
+                (0, external_vitest_namespaceObject.expect)(result.error).toContain("description");
+                (0, external_vitest_namespaceObject.expect)(result.error).toContain("systemPrompt");
+            }
+        });
+        (0, external_vitest_namespaceObject.it)("should fail validation for invalid tool names", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "Test",
+                systemPrompt: "Test",
+                tools: [
+                    "invalid_tool"
+                ]
+            };
+            const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
+            (0, external_vitest_namespaceObject.expect)(result.success).toBe(false);
+        });
+        (0, external_vitest_namespaceObject.it)("should apply default values for optional fields", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "Test",
+                systemPrompt: "Test"
+            };
+            const parsed = agentConfig_cjs_namespaceObject.AgentConfigSchema.parse(config);
+            (0, external_vitest_namespaceObject.expect)(parsed.allowScriptExecution).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(parsed.commandTimeout).toBe(300000);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Tool names enum", ()=>{
+        (0, external_vitest_namespaceObject.it)("should accept all valid tool names", ()=>{
+            const validTools = [
+                "internet_search",
+                "web_crawler",
+                "command_execute",
+                "think"
+            ];
+            for (const tool of validTools){
+                const config = {
+                    name: "test",
+                    description: "test",
+                    systemPrompt: "test",
+                    tools: [
+                        tool
+                    ]
+                };
+                const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
+                (0, external_vitest_namespaceObject.expect)(result.success).toBe(true);
+            }
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});