@hibanacloud/core 0.3.15

package/dist/src/subagents/types.d.ts

@@ -0,0 +1,218 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Content, FunctionDeclaration } from '@google/genai';
+/**
+ * Represents the storage level for a subagent configuration.
+ * - 'project': Stored in `.qwen/agents/` within the project directory
+ * - 'user': Stored in `~/.qwen/agents/` in the user's home directory
+ * - 'builtin': Built-in agents embedded in the codebase, always available
+ */
+export type SubagentLevel = 'project' | 'user' | 'builtin';
+/**
+ * Core configuration for a subagent as stored in Markdown files.
+ * This interface represents the file-based configuration that gets
+ * converted to runtime configuration for SubAgentScope.
+ */
+export interface SubagentConfig {
+    /** Unique name identifier for the subagent */
+    name: string;
+    /** Human-readable description of when and how to use this subagent */
+    description: string;
+    /**
+     * Optional list of tool names that this subagent is allowed to use.
+     * If omitted, the subagent inherits all available tools.
+     */
+    tools?: string[];
+    /**
+     * System prompt content that defines the subagent's behavior.
+     * Supports ${variable} templating via ContextState.
+     */
+    systemPrompt: string;
+    /** Storage level - determines where the configuration file is stored */
+    level: SubagentLevel;
+    /** Absolute path to the configuration file */
+    filePath: string;
+    /**
+     * Optional model configuration. If not provided, uses defaults.
+     * Can specify model name, temperature, and top_p values.
+     */
+    modelConfig?: Partial<ModelConfig>;
+    /**
+     * Optional runtime configuration. If not provided, uses defaults.
+     * Can specify max_time_minutes and max_turns.
+     */
+    runConfig?: Partial<RunConfig>;
+    /**
+     * Optional color for runtime display.
+     * If 'auto' or omitted, uses automatic color assignment.
+     */
+    color?: string;
+    /**
+     * Indicates whether this is a built-in agent.
+     * Built-in agents cannot be modified or deleted.
+     */
+    readonly isBuiltin?: boolean;
+}
+/**
+ * Runtime configuration that converts file-based config to existing SubAgentScope.
+ * This interface maps SubagentConfig to the existing runtime interfaces.
+ */
+export interface SubagentRuntimeConfig {
+    /** Prompt configuration for SubAgentScope */
+    promptConfig: PromptConfig;
+    /** Model configuration for SubAgentScope */
+    modelConfig: ModelConfig;
+    /** Runtime execution configuration for SubAgentScope */
+    runConfig: RunConfig;
+    /** Optional tool configuration for SubAgentScope */
+    toolConfig?: ToolConfig;
+}
+/**
+ * Result of a validation operation on a subagent configuration.
+ */
+export interface ValidationResult {
+    /** Whether the configuration is valid */
+    isValid: boolean;
+    /** Array of error messages if validation failed */
+    errors: string[];
+    /** Array of warning messages (non-blocking issues) */
+    warnings: string[];
+}
+/**
+ * Options for listing subagents.
+ */
+export interface ListSubagentsOptions {
+    /** Filter by storage level */
+    level?: SubagentLevel;
+    /** Filter by tool availability */
+    hasTool?: string;
+    /** Sort order for results */
+    sortBy?: 'name' | 'lastModified' | 'level';
+    /** Sort direction */
+    sortOrder?: 'asc' | 'desc';
+    /** Force refresh from disk, bypassing cache. Defaults to false. */
+    force?: boolean;
+}
+/**
+ * Options for creating a new subagent.
+ */
+export interface CreateSubagentOptions {
+    /** Storage level for the new subagent */
+    level: SubagentLevel;
+    /** Whether to overwrite existing subagent with same name */
+    overwrite?: boolean;
+    /** Custom directory path (overrides default level-based path) */
+    customPath?: string;
+}
+/**
+ * Error thrown when a subagent operation fails.
+ */
+export declare class SubagentError extends Error {
+    readonly code: string;
+    readonly subagentName?: string | undefined;
+    constructor(message: string, code: string, subagentName?: string | undefined);
+}
+/**
+ * Error codes for subagent operations.
+ */
+export declare const SubagentErrorCode: {
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly ALREADY_EXISTS: "ALREADY_EXISTS";
+    readonly INVALID_CONFIG: "INVALID_CONFIG";
+    readonly INVALID_NAME: "INVALID_NAME";
+    readonly FILE_ERROR: "FILE_ERROR";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly TOOL_NOT_FOUND: "TOOL_NOT_FOUND";
+};
+export type SubagentErrorCode = (typeof SubagentErrorCode)[keyof typeof SubagentErrorCode];
+/**
+ * Describes the possible termination modes for a subagent.
+ * This enum provides a clear indication of why a subagent's execution might have ended.
+ */
+export declare enum SubagentTerminateMode {
+    /**
+     * Indicates that the subagent's execution terminated due to an unrecoverable error.
+     */
+    ERROR = "ERROR",
+    /**
+     * Indicates that the subagent's execution terminated because it exceeded the maximum allowed working time.
+     */
+    TIMEOUT = "TIMEOUT",
+    /**
+     * Indicates that the subagent's execution successfully completed all its defined goals.
+     */
+    GOAL = "GOAL",
+    /**
+     * Indicates that the subagent's execution terminated because it exceeded the maximum number of turns.
+     */
+    MAX_TURNS = "MAX_TURNS",
+    /**
+     * Indicates that the subagent's execution was cancelled via an abort signal.
+     */
+    CANCELLED = "CANCELLED"
+}
+/**
+ * Configures the initial prompt for the subagent.
+ */
+export interface PromptConfig {
+    /**
+     * A single system prompt string that defines the subagent's persona and instructions.
+     * Note: You should use either `systemPrompt` or `initialMessages`, but not both.
+     */
+    systemPrompt?: string;
+    /**
+     * An array of user/model content pairs to seed the chat history for few-shot prompting.
+     * Note: You should use either `systemPrompt` or `initialMessages`, but not both.
+     */
+    initialMessages?: Content[];
+}
+/**
+ * Configures the tools available to the subagent during its execution.
+ */
+export interface ToolConfig {
+    /**
+     * A list of tool names (from the tool registry) or full function declarations
+     * that the subagent is permitted to use.
+     */
+    tools: Array<string | FunctionDeclaration>;
+}
+/**
+ * Configures the generative model parameters for the subagent.
+ * This interface specifies the model to be used and its associated generation settings,
+ * such as temperature and top-p values, which influence the creativity and diversity of the model's output.
+ */
+export interface ModelConfig {
+    /**
+     * The name or identifier of the model to be used (e.g., 'qwen3-coder-plus').
+     *
+     * TODO: In the future, this needs to support 'auto' or some other string to support routing use cases.
+     */
+    model?: string;
+    /**
+     * The temperature for the model's sampling process.
+     */
+    temp?: number;
+    /**
+     * The top-p value for nucleus sampling.
+     */
+    top_p?: number;
+}
+/**
+ * Configures the execution environment and constraints for the subagent.
+ * This interface defines parameters that control the subagent's runtime behavior,
+ * such as maximum execution time, to prevent infinite loops or excessive resource consumption.
+ *
+ * TODO: Consider adding max_tokens as a form of budgeting.
+ */
+export interface RunConfig {
+    /** The maximum execution time for the subagent in minutes. */
+    max_time_minutes?: number;
+    /**
+     * The maximum number of conversational turns (a user message + model response)
+     * before the execution is terminated. Helps prevent infinite loops.
+     */
+    max_turns?: number;
+}

package/dist/src/subagents/types.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Error thrown when a subagent operation fails.
+ */
+export class SubagentError extends Error {
+    code;
+    subagentName;
+    constructor(message, code, subagentName) {
+        super(message);
+        this.code = code;
+        this.subagentName = subagentName;
+        this.name = 'SubagentError';
+    }
+}
+/**
+ * Error codes for subagent operations.
+ */
+export const SubagentErrorCode = {
+    NOT_FOUND: 'NOT_FOUND',
+    ALREADY_EXISTS: 'ALREADY_EXISTS',
+    INVALID_CONFIG: 'INVALID_CONFIG',
+    INVALID_NAME: 'INVALID_NAME',
+    FILE_ERROR: 'FILE_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    TOOL_NOT_FOUND: 'TOOL_NOT_FOUND',
+};
+/**
+ * Describes the possible termination modes for a subagent.
+ * This enum provides a clear indication of why a subagent's execution might have ended.
+ */
+export var SubagentTerminateMode;
+(function (SubagentTerminateMode) {
+    /**
+     * Indicates that the subagent's execution terminated due to an unrecoverable error.
+     */
+    SubagentTerminateMode["ERROR"] = "ERROR";
+    /**
+     * Indicates that the subagent's execution terminated because it exceeded the maximum allowed working time.
+     */
+    SubagentTerminateMode["TIMEOUT"] = "TIMEOUT";
+    /**
+     * Indicates that the subagent's execution successfully completed all its defined goals.
+     */
+    SubagentTerminateMode["GOAL"] = "GOAL";
+    /**
+     * Indicates that the subagent's execution terminated because it exceeded the maximum number of turns.
+     */
+    SubagentTerminateMode["MAX_TURNS"] = "MAX_TURNS";
+    /**
+     * Indicates that the subagent's execution was cancelled via an abort signal.
+     */
+    SubagentTerminateMode["CANCELLED"] = "CANCELLED";
+})(SubagentTerminateMode || (SubagentTerminateMode = {}));
+//# sourceMappingURL=types.js.map

package/dist/src/subagents/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/subagents/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqIH;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,KAAK;IAG3B;IACA;IAHX,YACE,OAAe,EACN,IAAY,EACZ,YAAqB;QAE9B,KAAK,CAAC,OAAO,CAAC,CAAC;QAHN,SAAI,GAAJ,IAAI,CAAQ;QACZ,iBAAY,GAAZ,YAAY,CAAS;QAG9B,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW;IACtB,cAAc,EAAE,gBAAgB;IAChC,cAAc,EAAE,gBAAgB;IAChC,YAAY,EAAE,cAAc;IAC5B,UAAU,EAAE,YAAY;IACxB,gBAAgB,EAAE,kBAAkB;IACpC,cAAc,EAAE,gBAAgB;CACxB,CAAC;AAKX;;;GAGG;AACH,MAAM,CAAN,IAAY,qBAqBX;AArBD,WAAY,qBAAqB;IAC/B;;OAEG;IACH,wCAAe,CAAA;IACf;;OAEG;IACH,4CAAmB,CAAA;IACnB;;OAEG;IACH,sCAAa,CAAA;IACb;;OAEG;IACH,gDAAuB,CAAA;IACvB;;OAEG;IACH,gDAAuB,CAAA;AACzB,CAAC,EArBW,qBAAqB,KAArB,qBAAqB,QAqBhC"}

package/dist/src/subagents/types.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/subagents/types.test.js

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect } from 'vitest';
+import { SubagentError, SubagentErrorCode } from './types.js';
+describe('SubagentError', () => {
+    it('should create error with message and code', () => {
+        const error = new SubagentError('Test error', SubagentErrorCode.NOT_FOUND);
+        expect(error).toBeInstanceOf(Error);
+        expect(error.name).toBe('SubagentError');
+        expect(error.message).toBe('Test error');
+        expect(error.code).toBe(SubagentErrorCode.NOT_FOUND);
+        expect(error.subagentName).toBeUndefined();
+    });
+    it('should create error with subagent name', () => {
+        const error = new SubagentError('Test error', SubagentErrorCode.INVALID_CONFIG, 'test-agent');
+        expect(error.subagentName).toBe('test-agent');
+    });
+    it('should have correct error codes', () => {
+        expect(SubagentErrorCode.NOT_FOUND).toBe('NOT_FOUND');
+        expect(SubagentErrorCode.ALREADY_EXISTS).toBe('ALREADY_EXISTS');
+        expect(SubagentErrorCode.INVALID_CONFIG).toBe('INVALID_CONFIG');
+        expect(SubagentErrorCode.INVALID_NAME).toBe('INVALID_NAME');
+        expect(SubagentErrorCode.FILE_ERROR).toBe('FILE_ERROR');
+        expect(SubagentErrorCode.VALIDATION_ERROR).toBe('VALIDATION_ERROR');
+        expect(SubagentErrorCode.TOOL_NOT_FOUND).toBe('TOOL_NOT_FOUND');
+    });
+});
+//# sourceMappingURL=types.test.js.map

package/dist/src/subagents/types.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.test.js","sourceRoot":"","sources":["../../../src/subagents/types.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE9D,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,MAAM,KAAK,GAAG,IAAI,aAAa,CAAC,YAAY,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAE3E,MAAM,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACpC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACzC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACzC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACrD,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,aAAa,EAAE,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAChD,MAAM,KAAK,GAAG,IAAI,aAAa,CAC7B,YAAY,EACZ,iBAAiB,CAAC,cAAc,EAChC,YAAY,CACb,CAAC;QAEF,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;QACzC,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACtD,MAAM,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAChE,MAAM,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAChE,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC5D,MAAM,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACxD,MAAM,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACpE,MAAM,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/src/subagents/validation.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ModelConfig, RunConfig, SubagentConfig, ValidationResult } from './types.js';
+/**
+ * Validates subagent configurations to ensure they are well-formed
+ * and compatible with the runtime system.
+ */
+export declare class SubagentValidator {
+    /**
+     * Validates a complete subagent configuration.
+     *
+     * @param config - The subagent configuration to validate
+     * @returns ValidationResult with errors and warnings
+     */
+    validateConfig(config: SubagentConfig): ValidationResult;
+    /**
+     * Validates a subagent name.
+     * Names must be valid identifiers that can be used in file paths and tool calls.
+     *
+     * @param name - The name to validate
+     * @returns ValidationResult
+     */
+    validateName(name: string): ValidationResult;
+    /**
+     * Validates a system prompt.
+     *
+     * @param prompt - The system prompt to validate
+     * @returns ValidationResult
+     */
+    validateSystemPrompt(prompt: string): ValidationResult;
+    /**
+     * Validates a list of tool names.
+     *
+     * @param tools - Array of tool names to validate
+     * @returns ValidationResult
+     */
+    validateTools(tools: string[]): ValidationResult;
+    /**
+     * Validates model configuration.
+     *
+     * @param modelConfig - Partial model configuration to validate
+     * @returns ValidationResult
+     */
+    validateModelConfig(modelConfig: ModelConfig): ValidationResult;
+    /**
+     * Validates runtime configuration.
+     *
+     * @param runConfig - Partial run configuration to validate
+     * @returns ValidationResult
+     */
+    validateRunConfig(runConfig: RunConfig): ValidationResult;
+    /**
+     * Throws a SubagentError if validation fails.
+     *
+     * @param config - Configuration to validate
+     * @param subagentName - Name for error context
+     * @throws SubagentError if validation fails
+     */
+    validateOrThrow(config: SubagentConfig, subagentName?: string): void;
+}

package/dist/src/subagents/validation.js

@@ -0,0 +1,293 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SubagentError, SubagentErrorCode } from './types.js';
+/**
+ * Validates subagent configurations to ensure they are well-formed
+ * and compatible with the runtime system.
+ */
+export class SubagentValidator {
+    /**
+     * Validates a complete subagent configuration.
+     *
+     * @param config - The subagent configuration to validate
+     * @returns ValidationResult with errors and warnings
+     */
+    validateConfig(config) {
+        const errors = [];
+        const warnings = [];
+        // Validate name
+        const nameValidation = this.validateName(config.name);
+        if (!nameValidation.isValid) {
+            errors.push(...nameValidation.errors);
+        }
+        // Validate description
+        if (!config.description || config.description.trim().length === 0) {
+            errors.push('Description is required and cannot be empty');
+        }
+        else if (config.description.length > 500) {
+            warnings.push('Description is quite long (>500 chars), consider shortening for better readability');
+        }
+        // Validate system prompt
+        const promptValidation = this.validateSystemPrompt(config.systemPrompt);
+        if (!promptValidation.isValid) {
+            errors.push(...promptValidation.errors);
+        }
+        warnings.push(...promptValidation.warnings);
+        // Validate tools if specified
+        if (config.tools) {
+            const toolsValidation = this.validateTools(config.tools);
+            if (!toolsValidation.isValid) {
+                errors.push(...toolsValidation.errors);
+            }
+            warnings.push(...toolsValidation.warnings);
+        }
+        // Validate model config if specified
+        if (config.modelConfig) {
+            const modelValidation = this.validateModelConfig(config.modelConfig);
+            if (!modelValidation.isValid) {
+                errors.push(...modelValidation.errors);
+            }
+            warnings.push(...modelValidation.warnings);
+        }
+        // Validate run config if specified
+        if (config.runConfig) {
+            const runValidation = this.validateRunConfig(config.runConfig);
+            if (!runValidation.isValid) {
+                errors.push(...runValidation.errors);
+            }
+            warnings.push(...runValidation.warnings);
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validates a subagent name.
+     * Names must be valid identifiers that can be used in file paths and tool calls.
+     *
+     * @param name - The name to validate
+     * @returns ValidationResult
+     */
+    validateName(name) {
+        const errors = [];
+        const warnings = [];
+        if (!name || name.trim().length === 0) {
+            errors.push('Name is required and cannot be empty');
+            return { isValid: false, errors, warnings };
+        }
+        const trimmedName = name.trim();
+        // Check length constraints
+        if (trimmedName.length < 2) {
+            errors.push('Name must be at least 2 characters long');
+        }
+        if (trimmedName.length > 50) {
+            errors.push('Name must be 50 characters or less');
+        }
+        // Check valid characters (alphanumeric, hyphens, underscores)
+        const validNameRegex = /^[a-zA-Z0-9_-]+$/;
+        if (!validNameRegex.test(trimmedName)) {
+            errors.push('Name can only contain letters, numbers, hyphens, and underscores');
+        }
+        // Check that it doesn't start or end with special characters
+        if (trimmedName.startsWith('-') || trimmedName.startsWith('_')) {
+            errors.push('Name cannot start with a hyphen or underscore');
+        }
+        if (trimmedName.endsWith('-') || trimmedName.endsWith('_')) {
+            errors.push('Name cannot end with a hyphen or underscore');
+        }
+        // Check for reserved names
+        const reservedNames = [
+            'self',
+            'system',
+            'user',
+            'model',
+            'tool',
+            'config',
+            'default',
+        ];
+        if (reservedNames.includes(trimmedName.toLowerCase())) {
+            errors.push(`"${trimmedName}" is a reserved name and cannot be used`);
+        }
+        // Warnings for naming conventions
+        if (trimmedName !== trimmedName.toLowerCase()) {
+            warnings.push('Consider using lowercase names for consistency');
+        }
+        if (trimmedName.includes('_') && trimmedName.includes('-')) {
+            warnings.push('Consider using either hyphens or underscores consistently, not both');
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validates a system prompt.
+     *
+     * @param prompt - The system prompt to validate
+     * @returns ValidationResult
+     */
+    validateSystemPrompt(prompt) {
+        const errors = [];
+        const warnings = [];
+        if (!prompt || prompt.trim().length === 0) {
+            errors.push('System prompt is required and cannot be empty');
+            return { isValid: false, errors, warnings };
+        }
+        const trimmedPrompt = prompt.trim();
+        // Check minimum length for meaningful prompts
+        if (trimmedPrompt.length < 10) {
+            errors.push('System prompt must be at least 10 characters long');
+        }
+        // Check maximum length to prevent token issues
+        if (trimmedPrompt.length > 10000) {
+            errors.push('System prompt is too long (>10,000 characters)');
+        }
+        else if (trimmedPrompt.length > 5000) {
+            warnings.push('System prompt is quite long (>5,000 characters), consider shortening');
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validates a list of tool names.
+     *
+     * @param tools - Array of tool names to validate
+     * @returns ValidationResult
+     */
+    validateTools(tools) {
+        const errors = [];
+        const warnings = [];
+        if (!Array.isArray(tools)) {
+            errors.push('Tools must be an array of strings');
+            return { isValid: false, errors, warnings };
+        }
+        if (tools.length === 0) {
+            warnings.push('Empty tools array - subagent will inherit all available tools');
+            return { isValid: true, errors, warnings };
+        }
+        // Check for duplicates
+        const uniqueTools = new Set(tools);
+        if (uniqueTools.size !== tools.length) {
+            warnings.push('Duplicate tool names found in tools array');
+        }
+        // Validate each tool name
+        for (const tool of tools) {
+            if (typeof tool !== 'string') {
+                errors.push(`Tool name must be a string, got: ${typeof tool}`);
+                continue;
+            }
+            if (tool.trim().length === 0) {
+                errors.push('Tool name cannot be empty');
+                continue;
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validates model configuration.
+     *
+     * @param modelConfig - Partial model configuration to validate
+     * @returns ValidationResult
+     */
+    validateModelConfig(modelConfig) {
+        const errors = [];
+        const warnings = [];
+        if (modelConfig.model !== undefined) {
+            if (typeof modelConfig.model !== 'string' ||
+                modelConfig.model.trim().length === 0) {
+                errors.push('Model name must be a non-empty string');
+            }
+        }
+        if (modelConfig.temp !== undefined) {
+            if (typeof modelConfig.temp !== 'number') {
+                errors.push('Temperature must be a number');
+            }
+            else if (modelConfig.temp < 0 || modelConfig.temp > 2) {
+                errors.push('Temperature must be between 0 and 2');
+            }
+            else if (modelConfig.temp > 1) {
+                warnings.push('High temperature (>1) may produce very creative but unpredictable results');
+            }
+        }
+        if (modelConfig.top_p !== undefined) {
+            if (typeof modelConfig.top_p !== 'number') {
+                errors.push('top_p must be a number');
+            }
+            else if (modelConfig.top_p < 0 || modelConfig.top_p > 1) {
+                errors.push('top_p must be between 0 and 1');
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validates runtime configuration.
+     *
+     * @param runConfig - Partial run configuration to validate
+     * @returns ValidationResult
+     */
+    validateRunConfig(runConfig) {
+        const errors = [];
+        const warnings = [];
+        if (runConfig.max_time_minutes !== undefined) {
+            if (typeof runConfig.max_time_minutes !== 'number') {
+                errors.push('max_time_minutes must be a number');
+            }
+            else if (runConfig.max_time_minutes <= 0) {
+                errors.push('max_time_minutes must be greater than 0');
+            }
+            else if (runConfig.max_time_minutes > 60) {
+                warnings.push('Very long execution time (>60 minutes) may cause resource issues');
+            }
+        }
+        if (runConfig.max_turns !== undefined) {
+            if (typeof runConfig.max_turns !== 'number') {
+                errors.push('max_turns must be a number');
+            }
+            else if (runConfig.max_turns <= 0) {
+                errors.push('max_turns must be greater than 0');
+            }
+            else if (!Number.isInteger(runConfig.max_turns)) {
+                errors.push('max_turns must be an integer');
+            }
+            else if (runConfig.max_turns > 100) {
+                warnings.push('Very high turn limit (>100) may cause long execution times');
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Throws a SubagentError if validation fails.
+     *
+     * @param config - Configuration to validate
+     * @param subagentName - Name for error context
+     * @throws SubagentError if validation fails
+     */
+    validateOrThrow(config, subagentName) {
+        const result = this.validateConfig(config);
+        if (!result.isValid) {
+            throw new SubagentError(`Validation failed: ${result.errors.join(', ')}`, SubagentErrorCode.VALIDATION_ERROR, subagentName || config.name);
+        }
+    }
+}
+//# sourceMappingURL=validation.js.map