@besales/mcp 0.1.0 → 0.11.1

package/dist/tools/definitions.js

@@ -1,859 +1,17 @@
-import { z } from 'zod';
-const uuidSchema = z.string().uuid();
-const anyObjectSchema = z.object({}).passthrough();
-const optionalAnyObjectSchema = anyObjectSchema.optional();
-const outcomeSchema = z.enum(['won', 'lost', 'in_progress']);
-const platformSetupConfirmationSchema = {
-    explicit_confirmation: z.boolean().optional(),
-    confirmation_reason: z.string().optional(),
-};
-const modelLaneSchema = z.enum(['CHEAP', 'STANDARD', 'DEEP']);
-const routingStrategySchema = z.enum(['LEAD_STATUS', 'CUSTOM_VARIABLE']);
-const triggerScopeSchema = z.enum(['ON_USER_MESSAGE']).optional();
-const followUpSequenceTypeSchema = z.enum([
-    'MEETING_REMINDER',
-    'INACTIVE_USER_REACTIVATION',
-    'LOST_CLIENTS',
-]);
-const followUpTriggerSchema = z.enum([
-    'USER_INACTIVITY',
-    'DEAL_CLOSED',
-    'BIRTHDAY_DATE',
-    'MEETING_TIME',
-    'CUSTOM_SCHEDULE',
-    'LOST_CLIENTS',
-]);
-const analysisModeSchema = z.enum([
-    'grammar',
-    'structure',
-    'industry',
-    'contradictions',
-    'completeness',
-]);
-const promptGenerationStageOutputSchema = z.object({
-    name: z.enum(['structure_builder', 'industry_validator', 'prompt_tester', 'finalizer']),
-    output: anyObjectSchema,
-});
-const promptIterationStageOutputSchema = z.object({
-    name: z.enum(['iteration_analysis', 'iteration_recommendation']),
-    output: anyObjectSchema,
-});
-const promptAnalysisStageOutputSchema = z.object({
-    name: z.enum(['grammar', 'industry', 'structure', 'aggregation']),
-    output: anyObjectSchema,
-});
-const icpAnalysisSegmentSchema = z.object({
-    id: uuidSchema.optional(),
-    name: z.string(),
-    description: z.string().optional(),
-    demographics: optionalAnyObjectSchema,
-    pains: z.array(z.unknown()).optional(),
-    motivations: z.array(z.unknown()).optional(),
-    language_style: optionalAnyObjectSchema,
-});
-const icpAnalysisPersonaSchema = z.object({
-    name: z.string(),
-    segment_id: uuidSchema,
-    description: z.string().optional(),
-    pain_points: z.array(z.unknown()).optional(),
-    goals: z.array(z.unknown()).optional(),
-    objections: optionalAnyObjectSchema,
-    messaging_hints: optionalAnyObjectSchema,
-});
-const feedbackSchema = z.object({
-    general_comments: z.string().optional(),
-    selections: z.array(anyObjectSchema).optional(),
-});
-const sandboxFindingSchema = z.object({
-    scenario_id: uuidSchema.optional(),
-    category: z.enum([
-        'hallucination',
-        'wrong_action',
-        'missed_trigger',
-        'wrong_pipeline_transition',
-        'rag_miss',
-        'bad_tone',
-        'other',
-    ]),
-    severity: z.enum(['low', 'medium', 'critical']),
-    message: z.string(),
-    suggestion: z.string().optional(),
-    turn_index: z.number().int().optional(),
-});
-const simulationFindingSchema = z.object({
-    dialogue_id: uuidSchema.optional(),
-    category: z.enum([
-        'hallucination',
-        'wrong_action',
-        'bad_tone',
-        'missed_context',
-        'contradiction',
-        'off_topic',
-        'other',
-    ]),
-    severity: z.enum(['low', 'medium', 'critical']),
-    message: z.string(),
-    suggestion: z.string().optional(),
-    reference_message_index: z.number().int().optional(),
-});
-const routingRuleLeadStatusSchema = z.object({
-    lead_status_name: z.string().nullable().optional(),
-    lead_status_pipeline_crm_id: z.string().nullable().optional(),
-    lead_status_pipeline_id: z.number().int().nullable().optional(),
-    lead_status_id: z.number().int().nullable().optional(),
-});
-const agentToolPatchSchema = z.object({
-    tool_id: z.string(),
-    priority: z.number().int().min(1).max(100).optional(),
-    is_enabled: z.boolean().optional(),
-    agent_specific_conditions: anyObjectSchema.nullable().optional(),
-});
+import { agentDesignTools } from './definitions/agent-design.js';
+import { platformSetupTools } from './definitions/platform-setup.js';
+import { knowledgeTools } from './definitions/knowledge.js';
+import { crmPlatformTools } from './definitions/crm-platform.js';
+import { dataSourceTools } from './definitions/datasource.js';
+import { sessionTools } from './definitions/session.js';
+import { modelComparisonTools } from './definitions/model-comparison.js';
 export const toolDefinitions = [
-    defineTool({
-        name: 'besales_icp_create',
-        requiredFields: ['name'],
-        defaultWorkspaceId: true,
-        schema: z.object({
-            workspace_id: uuidSchema.optional(),
-            name: z.string(),
-            description: z.string().optional(),
-            source: z
-                .enum(['from_dialogues', 'from_files', 'from_scratch', 'ai_generated'])
-                .default('from_scratch'),
-        }),
-        createRequest: (input) => ({
-            path: `/workspaces/${input.workspace_id}/icp`,
-            body: compactObject({
-                name: input.name,
-                description: input.description,
-                source: {
-                    type: input.source === 'ai_generated' ? 'from_scratch' : input.source,
-                },
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_icp_import_dialogues',
-        requiredFields: ['icp_id', 'crm_connection_id', 'gdpr_confirmed'],
-        schema: z.object({
-            icp_id: uuidSchema,
-            crm_connection_id: uuidSchema,
-            outcome_filter: z.array(outcomeSchema).default(['won', 'lost']),
-            days_ago: z.number().int().min(1).max(730).default(180),
-            anonymize: z.boolean().default(true),
-            gdpr_confirmed: z.boolean(),
-        }),
-        createRequest: (input) => ({
-            path: `/icp/${input.icp_id}/samples/import-from-crm`,
-            body: {
-                crmConnectionId: input.crm_connection_id,
-                outcomeFilter: input.outcome_filter,
-                ageFilter: { daysAgo: input.days_ago },
-                anonymize: input.anonymize,
-                gdprConfirmed: input.gdpr_confirmed,
-            },
-        }),
-    }),
-    defineTool({
-        name: 'besales_icp_analysis_get_instructions',
-        requiredFields: ['icp_profile_id'],
-        defaultWorkspaceId: true,
-        schema: z.object({
-            workspace_id: uuidSchema.optional(),
-            icp_profile_id: uuidSchema,
-            business_context: optionalAnyObjectSchema,
-        }),
-        createRequest: (input) => ({
-            path: `/workspaces/${input.workspace_id}/icp/instructions`,
-            body: compactObject({
-                icpProfileId: input.icp_profile_id,
-                businessContext: input.business_context,
-            }),
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Выполни 3 stages ICP analysis локально: segment_clustering, classification, persona_generation.',
-            'Используй returned schemas для structured output и не меняй operationId.',
-            'Для каждого нового segment укажи валидный UUID id; persona.segment_id должен точно совпадать с существующим segment id или UUID из segments[].id.',
-            'После всех stages вызови besales_icp_analysis_submit с segments и personas.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_icp_analysis_submit',
-        requiredFields: ['operation_id', 'icp_profile_id', 'segments', 'personas'],
-        defaultWorkspaceId: true,
-        schema: z.object({
-            workspace_id: uuidSchema.optional(),
-            operation_id: uuidSchema,
-            icp_profile_id: uuidSchema,
-            segments: z.array(icpAnalysisSegmentSchema),
-            personas: z.array(icpAnalysisPersonaSchema),
-        }),
-        createRequest: (input) => ({
-            path: `/workspaces/${input.workspace_id}/icp/external-submit`,
-            body: {
-                operationId: input.operation_id,
-                icpProfileId: input.icp_profile_id,
-                segments: input.segments.map((segment) => compactObject({
-                    id: segment.id,
-                    name: segment.name,
-                    description: segment.description,
-                    demographics: segment.demographics,
-                    pains: segment.pains,
-                    motivations: segment.motivations,
-                    languageStyle: segment.language_style,
-                })),
-                personas: input.personas.map((persona) => compactObject({
-                    name: persona.name,
-                    segmentId: persona.segment_id,
-                    description: persona.description,
-                    painPoints: persona.pain_points,
-                    goals: persona.goals,
-                    objections: persona.objections,
-                    messagingHints: persona.messaging_hints,
-                })),
-            },
-        }),
-        restartToolName: 'besales_icp_analysis_get_instructions',
-    }),
-    defineTool({
-        name: 'besales_prompt_generate_get_instructions',
-        requiredFields: ['agent_id'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            icp_profile_id: uuidSchema.optional(),
-            business_context: optionalAnyObjectSchema,
-            style_hints: z
-                .object({
-                formality: z.enum(['formal', 'casual', 'friendly']).optional(),
-                verbosity: z.enum(['concise', 'balanced', 'detailed']).optional(),
-                language: z.string().default('ru'),
-            })
-                .optional(),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/generate/instructions`,
-            body: compactObject({
-                sourceType: input.icp_profile_id ? 'icp_full' : 'business_context_only',
-                icpProfileId: input.icp_profile_id,
-                businessContext: input.business_context,
-                styleHints: input.style_hints,
-            }),
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Выполни 4 stages prompt generation локально: structure_builder, industry_validator, prompt_tester, finalizer.',
-            'Каждая stage должна вернуть JSON по своей schema. Финальный compiled prompt положи в final_content.',
-            'После stages вызови besales_prompt_generate_submit с stages, final_content и metadata.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_prompt_generate_submit',
-        requiredFields: ['agent_id', 'operation_id', 'stages', 'final_content'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            operation_id: uuidSchema,
-            stages: z.array(promptGenerationStageOutputSchema).min(4),
-            final_content: z.string(),
-            metadata: z
-                .object({
-                total_tokens: z.number().int().optional(),
-                models: z.record(z.string(), z.string()).optional(),
-            })
-                .optional(),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/generate/${input.operation_id}/submit`,
-            body: compactObject({
-                stages: input.stages,
-                finalContent: input.final_content,
-                metadata: input.metadata
-                    ? compactObject({
-                        totalTokens: input.metadata.total_tokens,
-                        models: input.metadata.models,
-                    })
-                    : undefined,
-            }),
-        }),
-        restartToolName: 'besales_prompt_generate_get_instructions',
-    }),
-    defineTool({
-        name: 'besales_prompt_iterate_get_instructions',
-        requiredFields: ['agent_id', 'base_version_id', 'feedback'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            base_version_id: uuidSchema,
-            feedback: feedbackSchema,
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/iterate/instructions`,
-            body: {
-                baseVersionId: input.base_version_id,
-                feedback: compactObject({
-                    generalComments: input.feedback.general_comments,
-                    selections: input.feedback.selections,
-                }),
-            },
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Выполни 2 stages prompt iteration локально: iteration_analysis и iteration_recommendation.',
-            'Сохрани связь с baseVersionId и верни proposed_changes плюс preview_content.',
-            'После stages вызови besales_prompt_iterate_submit.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_prompt_iterate_submit',
-        requiredFields: ['agent_id', 'operation_id', 'stages', 'proposed_changes', 'preview_content'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            operation_id: uuidSchema,
-            stages: z.array(promptIterationStageOutputSchema).min(2),
-            proposed_changes: z.array(anyObjectSchema),
-            preview_content: z.string(),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/iterate/${input.operation_id}/submit`,
-            body: {
-                stages: input.stages,
-                proposedChanges: input.proposed_changes,
-                previewContent: input.preview_content,
-            },
-        }),
-        restartToolName: 'besales_prompt_iterate_get_instructions',
-    }),
-    defineTool({
-        name: 'besales_prompt_analyze_get_instructions',
-        requiredFields: ['agent_id', 'version_id'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            version_id: uuidSchema,
-            modes: z.array(analysisModeSchema).default(['grammar', 'structure', 'contradictions']),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/analyze/instructions`,
-            body: {
-                versionId: input.version_id,
-                modes: input.modes,
-            },
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Выполни static analysis stages локально: grammar, industry, structure, aggregation.',
-            'Собери итоговый список issues без дублей и с severity.',
-            'После анализа вызови besales_prompt_analyze_submit с aggregated_issues.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_prompt_analyze_submit',
-        requiredFields: ['agent_id', 'operation_id', 'stages', 'aggregated_issues'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            operation_id: uuidSchema,
-            stages: z.array(promptAnalysisStageOutputSchema).min(4),
-            aggregated_issues: z.array(anyObjectSchema),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/analyze/${input.operation_id}/submit`,
-            body: {
-                stages: input.stages,
-                aggregatedIssues: input.aggregated_issues,
-            },
-        }),
-        restartToolName: 'besales_prompt_analyze_get_instructions',
-    }),
-    defineTool({
-        name: 'besales_prompt_finalize',
-        requiredFields: ['agent_id', 'draft_version_id'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            draft_version_id: uuidSchema,
-            changelog_note: z.string().optional(),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/approve`,
-            body: compactObject({
-                draftVersionId: input.draft_version_id,
-                changelogNote: input.changelog_note,
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_sandbox_run_start',
-        requiredFields: ['agent_id'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            scenario_ids: z.array(uuidSchema).optional(),
-            options: z
-                .object({
-                check_routing: z.boolean().default(false),
-                check_pipeline_transitions: z.boolean().default(false),
-                check_agent_actions: z.boolean().default(false),
-                run_rag_golden_tests: z.boolean().default(false),
-                turns_per_scenario: z.number().int().min(1).max(50).default(10),
-            })
-                .optional(),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/sandbox-runs`,
-            body: compactObject({
-                scenarioIds: input.scenario_ids,
-                options: input.options
-                    ? {
-                        checkRouting: input.options.check_routing,
-                        checkPipelineTransitions: input.options.check_pipeline_transitions,
-                        checkAgentActions: input.options.check_agent_actions,
-                        runRagGoldenTests: input.options.run_rag_golden_tests,
-                        turnsPerScenario: input.options.turns_per_scenario,
-                    }
-                    : undefined,
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_sandbox_findings_get_instructions',
-        requiredFields: ['agent_id', 'run_id'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            run_id: uuidSchema,
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/sandbox/runs/${input.run_id}/findings/instructions`,
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Проанализируй sandbox report локально и выдели structured findings.',
-            'Сгруппируй проблемы по scenario/turn/category/severity и предложи actionable fix.',
-            'После анализа вызови besales_sandbox_findings_submit.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_sandbox_findings_submit',
-        requiredFields: ['agent_id', 'run_id', 'operation_id', 'findings'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            run_id: uuidSchema,
-            operation_id: uuidSchema,
-            findings: z.array(sandboxFindingSchema),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/sandbox/runs/${input.run_id}/findings/${input.operation_id}/submit`,
-            body: {
-                findings: input.findings.map((finding) => compactObject({
-                    scenarioId: finding.scenario_id,
-                    category: finding.category,
-                    severity: finding.severity,
-                    message: finding.message,
-                    suggestion: finding.suggestion,
-                    turnIndex: finding.turn_index,
-                })),
-            },
-        }),
-        restartToolName: 'besales_sandbox_findings_get_instructions',
-    }),
-    defineTool({
-        name: 'besales_simulation_findings_get_instructions',
-        requiredFields: ['agent_id', 'simulation_id'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            simulation_id: uuidSchema,
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/simulate-findings/instructions`,
-            body: {
-                simulationId: input.simulation_id,
-            },
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Проанализируй simulation dialogues локально и найди hallucination, tone, off-topic и action issues.',
-            'Не отправляй raw simulation_id в submit body: он используется только для выбора route/context.',
-            'После анализа вызови besales_simulation_findings_submit.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_simulation_findings_submit',
-        requiredFields: ['agent_id', 'simulation_id', 'operation_id', 'findings'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            simulation_id: uuidSchema,
-            operation_id: uuidSchema,
-            findings: z.array(simulationFindingSchema),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/prompt/simulate-findings/${input.operation_id}/submit`,
-            body: {
-                findings: input.findings.map((finding) => compactObject({
-                    dialogueId: finding.dialogue_id,
-                    category: finding.category,
-                    severity: finding.severity,
-                    message: finding.message,
-                    suggestion: finding.suggestion,
-                    referenceMessageIndex: finding.reference_message_index,
-                })),
-            },
-        }),
-        restartToolName: 'besales_simulation_findings_get_instructions',
-    }),
-    defineTool({
-        name: 'besales_qa_generation_get_instructions',
-        requiredFields: ['agent_id'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            namespace_context: z.string().optional(),
-            company_context: z.string().optional(),
-            icp_profile_id: uuidSchema.optional(),
-            target_count: z.number().int().min(5).max(100).default(30),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/knowledge/qa-generation/instructions`,
-            body: compactObject({
-                namespaceContext: input.namespace_context,
-                companyContext: input.company_context,
-                icpProfileId: input.icp_profile_id,
-                targetCount: input.target_count,
-            }),
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Сгенерируй Q&A pairs локально по returned schema и company/namespace context.',
-            'Каждая пара должна быть пригодна для knowledge base: короткий вопрос, точный ответ, optional tags.',
-            'После генерации вызови besales_qa_generation_submit с qa_pairs.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_qa_generation_submit',
-        requiredFields: ['agent_id', 'operation_id', 'qa_pairs'],
-        schema: z.object({
-            agent_id: uuidSchema,
-            operation_id: uuidSchema,
-            knowledge_space_id: uuidSchema.optional(),
-            qa_pairs: z.array(z.object({
-                question: z.string(),
-                answer: z.string(),
-                tags: z.array(z.string()).optional(),
-            })),
-        }),
-        createRequest: (input) => ({
-            path: `/agents/${input.agent_id}/knowledge/qa-generation/${input.operation_id}/submit`,
-            body: compactObject({
-                knowledgeSpaceId: input.knowledge_space_id,
-                qaPairs: input.qa_pairs,
-            }),
-        }),
-        restartToolName: 'besales_qa_generation_get_instructions',
-    }),
-    defineTool({
-        name: 'besales_platform_context_get',
-        requiredFields: ['platform_id'],
-        schema: z.object({
-            platform_id: uuidSchema,
-        }),
-        createRequest: (input) => ({
-            method: 'GET',
-            path: `/platforms/${input.platform_id}/setup/context`,
-        }),
-        enhanceResponse: (response) => withInstructions(response, [
-            'Use this sanitized context first for Platform Setup Bridge flows.',
-            'Read readiness flags, then call targeted mutation tools. Do not ask the user for workspace_id.',
-            'Prompt content changes still go through besales_prompt_* tools and besales_prompt_finalize.',
-        ]),
-    }),
-    defineTool({
-        name: 'besales_agent_list',
-        requiredFields: ['platform_id'],
-        schema: z.object({
-            platform_id: uuidSchema,
-        }),
-        createRequest: (input) => ({
-            method: 'GET',
-            path: `/platforms/${input.platform_id}/agents`,
-        }),
-    }),
-    defineTool({
-        name: 'besales_agent_create',
-        requiredFields: ['platform_id', 'name', 'model_lane'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            name: z.string(),
-            description: z.string().nullable().optional(),
-            model_lane: modelLaneSchema,
-            default_icp_profile_id: uuidSchema.optional(),
-        }),
-        createRequest: (input) => ({
-            path: `/platforms/${input.platform_id}/agents`,
-            body: compactObject({
-                name: input.name,
-                description: input.description,
-                modelLane: input.model_lane,
-                defaultIcpProfileId: input.default_icp_profile_id,
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_agent_update',
-        requiredFields: ['platform_id', 'agent_id'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            agent_id: uuidSchema,
-            name: z.string().optional(),
-            description: z.string().nullable().optional(),
-            model_lane: modelLaneSchema.optional(),
-            default_icp_profile_id: uuidSchema.nullable().optional(),
-            use_global_history: z.boolean().optional(),
-            adapt_to_user_language: z.boolean().optional(),
-        }),
-        createRequest: (input) => ({
-            method: 'PATCH',
-            path: `/platforms/${input.platform_id}/agents/${input.agent_id}`,
-            body: compactObject({
-                name: input.name,
-                description: input.description,
-                modelLane: input.model_lane,
-                defaultIcpProfileId: input.default_icp_profile_id,
-                useGlobalHistory: input.use_global_history,
-                adaptToUserLanguage: input.adapt_to_user_language,
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_agent_tools_update',
-        requiredFields: ['platform_id', 'agent_id', 'tools'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            agent_id: uuidSchema,
-            tools: z.array(agentToolPatchSchema).min(1),
-        }),
-        createRequest: (input) => ({
-            method: 'PATCH',
-            path: `/platforms/${input.platform_id}/agents/${input.agent_id}/tools`,
-            body: {
-                tools: input.tools.map((tool) => compactObject({
-                    toolId: tool.tool_id,
-                    priority: tool.priority,
-                    isEnabled: tool.is_enabled,
-                    agentSpecificConditions: tool.agent_specific_conditions,
-                })),
-            },
-        }),
-    }),
-    defineTool({
-        name: 'besales_router_update',
-        requiredFields: ['platform_id'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            name: z.string().optional(),
-            model: z.string().optional(),
-            temperature: z.number().min(0).max(2).optional(),
-            max_tokens: z.number().int().min(1).nullable().optional(),
-            additional_prompt: z.string().nullable().optional(),
-            adapt_to_user_language: z.boolean().optional(),
-            skip_llm_routing: z.boolean().optional(),
-            direct_routing_agent_id: uuidSchema.nullable().optional(),
-            ...platformSetupConfirmationSchema,
-        }),
-        createRequest: (input) => ({
-            method: 'PATCH',
-            path: `/platforms/${input.platform_id}/router`,
-            body: compactObject({
-                name: input.name,
-                model: input.model,
-                temperature: input.temperature,
-                maxTokens: input.max_tokens,
-                additionalPrompt: input.additional_prompt,
-                adaptToUserLanguage: input.adapt_to_user_language,
-                skipLlmRouting: input.skip_llm_routing,
-                directRoutingAgentId: input.direct_routing_agent_id,
-                ...setupConfirmation(input),
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_routing_rule_upsert',
-        requiredFields: ['platform_id', 'routing_strategy', 'custom_router_prompt'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            routing_rule_id: uuidSchema.optional(),
-            routing_strategy: routingStrategySchema,
-            deal_mode: z.string().nullable().optional(),
-            custom_variable_id: uuidSchema.nullable().optional(),
-            variable_value: z.string().nullable().optional(),
-            custom_router_prompt: z.string(),
-            is_enabled: z.boolean().optional(),
-            priority: z.number().int().min(0).optional(),
-            skip_llm: z.boolean().optional(),
-            direct_agent_id: uuidSchema.nullable().optional(),
-            lead_statuses: z.array(routingRuleLeadStatusSchema).optional(),
-            ...platformSetupConfirmationSchema,
-        }),
-        createRequest: (input) => ({
-            method: input.routing_rule_id ? 'PATCH' : 'POST',
-            path: `/platforms/${input.platform_id}/router/routing-rules`,
-            body: compactObject({
-                routingRuleId: input.routing_rule_id,
-                routingStrategy: input.routing_strategy,
-                dealMode: input.deal_mode,
-                customVariableId: input.custom_variable_id,
-                variableValue: input.variable_value,
-                customRouterPrompt: input.custom_router_prompt,
-                isEnabled: input.is_enabled,
-                priority: input.priority,
-                skipLlm: input.skip_llm,
-                directAgentId: input.direct_agent_id,
-                leadStatuses: input.lead_statuses?.map((status) => compactObject({
-                    leadStatusName: status.lead_status_name,
-                    leadStatusPipelineCrmId: status.lead_status_pipeline_crm_id,
-                    leadStatusPipelineId: status.lead_status_pipeline_id,
-                    leadStatusId: status.lead_status_id,
-                })),
-                ...setupConfirmation(input),
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_trigger_upsert',
-        requiredFields: ['platform_id', 'agent_id'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            agent_id: uuidSchema,
-            trigger_id: uuidSchema.optional(),
-            name: z.string().optional(),
-            condition: z.string().optional(),
-            is_enabled: z.boolean().optional(),
-            priority: z.number().int().min(1).max(100).optional(),
-            stop_propagation: z.boolean().optional(),
-            scope: triggerScopeSchema,
-            metadata: anyObjectSchema.optional(),
-            actions: z.array(anyObjectSchema).optional(),
-            ...platformSetupConfirmationSchema,
-        }),
-        createRequest: (input) => ({
-            method: input.trigger_id ? 'PATCH' : 'POST',
-            path: input.trigger_id
-                ? `/platforms/${input.platform_id}/agents/${input.agent_id}/triggers/${input.trigger_id}`
-                : `/platforms/${input.platform_id}/agents/${input.agent_id}/triggers`,
-            body: compactObject({
-                name: input.name,
-                condition: input.condition,
-                isEnabled: input.is_enabled,
-                priority: input.priority,
-                stopPropagation: input.stop_propagation,
-                scope: input.scope,
-                metadata: input.metadata,
-                actions: input.actions,
-                ...setupConfirmation(input),
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_behavior_update',
-        requiredFields: ['platform_id', 'updates'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            updates: anyObjectSchema,
-            ...platformSetupConfirmationSchema,
-        }),
-        createRequest: (input) => ({
-            method: 'PATCH',
-            path: `/platforms/${input.platform_id}/agent-behavior`,
-            body: {
-                updates: input.updates,
-                ...setupConfirmation(input),
-            },
-        }),
-    }),
-    defineTool({
-        name: 'besales_followup_sequence_upsert',
-        requiredFields: ['platform_id', 'name', 'type', 'trigger', 'config'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            sequence_id: uuidSchema.optional(),
-            name: z.string(),
-            description: z.string().nullable().optional(),
-            type: followUpSequenceTypeSchema,
-            enabled: z.boolean().optional(),
-            trigger: followUpTriggerSchema,
-            config: anyObjectSchema,
-            ...platformSetupConfirmationSchema,
-        }),
-        createRequest: (input) => ({
-            method: input.sequence_id ? 'PATCH' : 'POST',
-            path: input.sequence_id
-                ? `/platforms/${input.platform_id}/follow-up/sequences/${input.sequence_id}`
-                : `/platforms/${input.platform_id}/follow-up/sequences`,
-            body: compactObject({
-                name: input.name,
-                description: input.description,
-                type: input.type,
-                enabled: input.enabled,
-                trigger: input.trigger,
-                config: input.config,
-                ...setupConfirmation(input),
-            }),
-        }),
-    }),
-    defineTool({
-        name: 'besales_pipeline_settings_update',
-        requiredFields: ['platform_id', 'updates'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            updates: anyObjectSchema,
-            ...platformSetupConfirmationSchema,
-        }),
-        createRequest: (input) => ({
-            method: 'PATCH',
-            path: `/platforms/${input.platform_id}/pipeline-settings`,
-            body: {
-                updates: input.updates,
-                ...setupConfirmation(input),
-            },
-        }),
-    }),
-    defineTool({
-        name: 'besales_platform_settings_update',
-        requiredFields: ['platform_id', 'settings'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            settings: anyObjectSchema,
-            ...platformSetupConfirmationSchema,
-        }),
-        createRequest: (input) => ({
-            method: 'PATCH',
-            path: `/platforms/${input.platform_id}/settings`,
-            body: {
-                ...input.settings,
-                ...setupConfirmation(input),
-            },
-        }),
-    }),
-    defineTool({
-        name: 'besales_audit_revert',
-        requiredFields: ['platform_id', 'audit_log_id'],
-        schema: z.object({
-            platform_id: uuidSchema,
-            audit_log_id: uuidSchema,
-        }),
-        createRequest: (input) => ({
-            path: `/platforms/${input.platform_id}/audit/${input.audit_log_id}/revert`,
-        }),
-    }),
+    ...agentDesignTools,
+    ...platformSetupTools,
+    ...knowledgeTools,
+    ...crmPlatformTools,
+    ...dataSourceTools,
+    ...sessionTools,
+    ...modelComparisonTools,
 ];
-function defineTool(definition) {
-    return definition;
-}
-function compactObject(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
-}
-function setupConfirmation(input) {
-    return compactObject({
-        explicitConfirmation: input.explicit_confirmation,
-        confirmationReason: input.confirmation_reason,
-    });
-}
-function withInstructions(response, instructions) {
-    const text = instructions.join('\n');
-    if (response && typeof response === 'object' && !Array.isArray(response)) {
-        return {
-            ...response,
-            instructions: text,
-        };
-    }
-    return {
-        result: response,
-        instructions: text,
-    };
-}
 //# sourceMappingURL=definitions.js.map