@besales/mcp 0.1.0

package/dist/tools/definitions.js

@@ -0,0 +1,859 @@
+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(),
+});
+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`,
+        }),
+    }),
+];
+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