@besales/mcp 0.1.0 → 0.11.1

package/dist/tools/definitions/agent-design.js

@@ -0,0 +1,643 @@
+import { z } from 'zod';
+import { analysisModeSchema, anyObjectSchema, buildListQuery, compactMetadata, compactObject, defineTool, generatedScenarioSchema, icpAnalysisPersonaSchema, icpAnalysisSegmentSchema, optionalAnyObjectSchema, outcomeSchema, promptAnalysisStageOutputSchema, promptGenerationStageOutputSchema, sandboxFindingSchema, simulationFindingSchema, uuidSchema, withInstructions, } from './shared.js';
+export const agentDesignTools = [
+    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'])
+                .default('from_scratch'),
+        }),
+        createRequest: (input) => ({
+            path: `/workspaces/${input.workspace_id}/icp`,
+            body: compactObject({
+                name: input.name,
+                description: input.description,
+                source: { type: input.source },
+            }),
+        }),
+    }),
+    defineTool({
+        name: 'besales_icp_import_dialogues',
+        requiredFields: ['icp_id'],
+        schema: z
+            .object({
+            icp_id: uuidSchema,
+            /**
+             * mode='text' (default) — импорт сохранённых текстовых диалогов из CRM history.
+             * mode='audio' — batch audio path через transcription-service: тянем call recordings
+             *   из источника (amocrm_leads / xlsx_upload / onlinepbx_direct), прогоняем через
+             *   Yandex SpeechKit STT, создаём IcpDialogueSample из транскрипта.
+             */
+            mode: z.enum(['text', 'audio']).default('text'),
+            // --- Text mode (legacy CRM history) ---
+            crm_connection_id: uuidSchema.optional(),
+            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().optional(),
+            // --- Audio mode (Phase 4 + Track B onlinePBX) ---
+            audio_source_type: z
+                .enum(['amocrm_leads', 'xlsx_upload', 'onlinepbx_direct', 'bitrix_openlines'])
+                .optional(),
+            /**
+             * Конфиг источника аудио — shape зависит от audio_source_type:
+             *   - amocrm_leads:     { crmConnectionId, leadIds[], defaultOutcome? }
+             *   - xlsx_upload:      { storedFileId, crmConnectionId }  (xlsx загрузи через POST /v2/files)
+             *   - onlinepbx_direct: { startDate, endDate, minDurationSec?=60, direction?='all',
+             *                         matchToCrm?=true, crmConnectionId?, defaultOutcome?='unknown',
+             *                         dryRun?=false, trunkId? } — звонки из onlinePBX за период,
+             *                         опц. матчинг к AmoCRM по телефону → outcome. dryRun=true →
+             *                         только подсчёт (status=DRY_RUN, totalRefs=count) без запуска STT.
+             *   - bitrix_openlines: { crmConnectionId, startDate, endDate, categoryId?, dryRun? } —
+             *                         ТЕКСТОВЫЕ диалоги из Bitrix open-lines (сделки за период), без STT.
+             * NB: xlsx_drive (Google Drive) НЕ поддерживается бэкендом (MVP) — backend → 400.
+             */
+            audio_source_config: optionalAnyObjectSchema,
+            language: z.enum(['ru-RU', 'uz-UZ', 'kk-KZ', 'auto']).optional(),
+        })
+            .superRefine((value, ctx) => {
+            if (value.mode === 'audio') {
+                if (!value.audio_source_type || !value.audio_source_config) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: 'audio_source_type и audio_source_config обязательны при mode=audio',
+                        path: ['audio_source_type'],
+                    });
+                }
+            }
+            else {
+                if (!value.crm_connection_id || value.gdpr_confirmed !== true) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: 'crm_connection_id и gdpr_confirmed обязательны при mode=text',
+                        path: ['crm_connection_id'],
+                    });
+                }
+            }
+        }),
+        createRequest: (input) => {
+            if (input.mode === 'audio') {
+                return {
+                    method: 'POST',
+                    path: `/icp/audio-import-runs`,
+                    body: compactObject({
+                        icpProfileId: input.icp_id,
+                        sourceType: input.audio_source_type,
+                        sourceConfig: input.audio_source_config,
+                        language: input.language,
+                    }),
+                };
+            }
+            return {
+                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,
+                },
+            };
+        },
+        enhanceResponse: (response, input) => {
+            if (input.mode === 'audio') {
+                return withInstructions(response, [
+                    'Audio import — асинхронный. Получи runId из response.',
+                    'onlinepbx_direct + dryRun=true → response.status=DRY_RUN, totalRefs=число звонков ' +
+                        'после фильтра (Run НЕ создан). Подтверди объём и повтори с dryRun=false для импорта.',
+                    'Опрашивай статус через besales_icp_import_status каждые 30-60 сек.',
+                    'Терминальные статусы: COMPLETED, PARTIAL, FAILED.',
+                    'При PARTIAL — часть items expired/failed, но успешные диалоги уже в IcpDialogueSample.',
+                ]);
+            }
+            return response;
+        },
+    }),
+    defineTool({
+        name: 'besales_icp_import_status',
+        requiredFields: ['run_id'],
+        schema: z.object({
+            run_id: uuidSchema,
+        }),
+        createRequest: (input) => ({
+            method: 'GET',
+            path: `/icp/audio-import-runs/${input.run_id}`,
+        }),
+    }),
+    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_icp_list',
+        requiredFields: [],
+        defaultWorkspaceId: true,
+        schema: z.object({
+            workspace_id: uuidSchema.optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+            cursor: z.string().optional(),
+        }),
+        createRequest: (input) => ({
+            method: 'GET',
+            path: `/workspaces/${input.workspace_id}/icp${buildListQuery({ limit: input.limit, cursor: input.cursor })}`,
+        }),
+    }),
+    defineTool({
+        name: 'besales_icp_get',
+        requiredFields: ['icp_id'],
+        schema: z.object({
+            icp_id: uuidSchema,
+        }),
+        createRequest: (input) => ({
+            method: 'GET',
+            path: `/icp/${input.icp_id}`,
+        }),
+    }),
+    defineTool({
+        name: 'besales_icp_scenarios_list',
+        requiredFields: ['icp_id'],
+        schema: z.object({
+            icp_id: uuidSchema,
+        }),
+        createRequest: (input) => ({
+            method: 'GET',
+            path: `/icp/${input.icp_id}/scenarios`,
+        }),
+    }),
+    defineTool({
+        name: 'besales_icp_sample_messages',
+        requiredFields: ['sample_id'],
+        schema: z.object({
+            sample_id: uuidSchema,
+        }),
+        createRequest: (input) => ({
+            method: 'GET',
+            path: `/samples/${input.sample_id}/messages`,
+        }),
+    }),
+    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(),
+                // Язык РАССУЖДЕНИЯ стадий генерации (ru/en) — НЕ язык итогового промпта.
+                // Язык промпта = то, что ты пишешь в final_content (узбекский и т.д.).
+                language: z.enum(['ru', 'en']).default('ru'),
+                message_direction: z.enum(['INBOUND', 'OUTBOUND']).optional(),
+            })
+                .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
+                    ? compactObject({
+                        formality: input.style_hints.formality,
+                        verbosity: input.style_hints.verbosity,
+                        language: input.style_hints.language,
+                        messageDirection: input.style_hints.message_direction,
+                    })
+                    : undefined,
+            }),
+        }),
+        enhanceResponse: (response) => withInstructions(response, [
+            'Выполни 4 stages prompt generation локально: structure_builder, industry_validator, prompt_tester, finalizer.',
+            'Каждая stage должна вернуть JSON по своей schema. Финальный compiled prompt положи в final_content.',
+            'Язык итогового промпта = содержимое final_content: пиши его на языке бота (узбекский, казахский и т.д.). style_hints.language (ru/en) задаёт лишь язык рассуждения стадий, не язык промпта.',
+            'После 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: compactMetadata(input.metadata),
+            }),
+        }),
+        restartToolName: 'besales_prompt_generate_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,
+            }),
+        }),
+        enhanceResponse: (response) => withInstructions(response, [
+            'Промпт активирован. Перед запуском проверь 3 вещи: 1) greeting — besales_behavior_update.greeting, замени дефолтный «Привет!/Hello» на язык аудитории текстом, БЕЗ кнопок (greeting_buttons — лишь по явному запросу); для INBOUND именно оно открывает диалог; 2) knowledge привязан к каналу; 3) прогон besales_sandbox_run_start.',
+        ]),
+    }),
+    defineTool({
+        name: 'besales_sandbox_run_start',
+        requiredFields: ['agent_id'],
+        schema: z.object({
+            agent_id: uuidSchema,
+            scenario_ids: z.array(uuidSchema).optional(),
+            options: z
+                .object({
+                mode: z.enum(['single_agent', 'workflow']).default('single_agent'),
+                client_mode: z.enum(['scripted', 'simulated']).default('scripted'),
+                simulation: z
+                    .object({
+                    max_turns: z.number().int().min(1).max(30).optional(),
+                })
+                    .optional(),
+                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
+                    ? {
+                        mode: input.options.mode,
+                        clientMode: input.options.client_mode,
+                        simulation: input.options.simulation
+                            ? { maxTurns: input.options.simulation.max_turns }
+                            : undefined,
+                        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.',
+            'Если клиент в simulated-прогоне ушёл с outcome "refused" или endReason "gave_up" — ' +
+                'это не обязательно ошибка агента; оцени по тексту диалога, отработал ли агент корректно.',
+            'После анализа вызови 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', 'operation_id', 'findings'],
+        schema: z.object({
+            agent_id: uuidSchema,
+            // Принимается для непрерывности flow, но НЕ обязателен и не отправляется:
+            // backend восстанавливает simulationId из operation.referenceId по operation_id.
+            simulation_id: uuidSchema.optional(),
+            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_test_scenario_generate_get_instructions',
+        requiredFields: ['icp_profile_id'],
+        defaultWorkspaceId: true,
+        schema: z.object({
+            workspace_id: uuidSchema.optional(),
+            icp_profile_id: uuidSchema,
+            count: z.number().int().min(1).max(20).default(5),
+            business_context: optionalAnyObjectSchema,
+        }),
+        createRequest: (input) => ({
+            path: `/workspaces/${input.workspace_id}/test-scenarios/instructions`,
+            body: compactObject({
+                icpProfileId: input.icp_profile_id,
+                count: input.count,
+                businessContext: input.business_context,
+            }),
+        }),
+        enhanceResponse: (response) => withInstructions(response, [
+            'Выполни stage scenario_builder локально и верни структурированный JSON.',
+            'Уточни у пользователя целевой режим sandbox: изолированный агент (single_agent) или полный workflow с роутером (workflow). Для workflow добавь сценарии, провоцирующие смену агента — сдвиг темы/intent в ходе диалога.',
+            'Каждый scenario — короткий sandbox-готовый диалог: 1-4 turns, начинать ОБЯЗАТЕЛЬНО с role="client".',
+            'segment_ids должны ссылаться только на icpContext.segments[].id; не выдумывай UUID.',
+            'Покрой разные кейсы: happy path, возражение, edge case (раздражение / спешка / сомнение).',
+            'После генерации вызови besales_test_scenario_generate_submit с массивом scenarios.',
+        ]),
+    }),
+    defineTool({
+        name: 'besales_test_scenario_generate_submit',
+        requiredFields: ['operation_id', 'icp_profile_id', 'scenarios'],
+        defaultWorkspaceId: true,
+        schema: z.object({
+            workspace_id: uuidSchema.optional(),
+            operation_id: uuidSchema,
+            icp_profile_id: uuidSchema,
+            scenarios: z.array(generatedScenarioSchema).min(1).max(20),
+        }),
+        createRequest: (input) => ({
+            path: `/workspaces/${input.workspace_id}/test-scenarios/external-submit`,
+            body: {
+                operationId: input.operation_id,
+                icpProfileId: input.icp_profile_id,
+                scenarios: input.scenarios.map((scenario) => compactObject({
+                    name: scenario.name,
+                    description: scenario.description,
+                    segmentIds: scenario.segment_ids,
+                    situations: scenario.situations.map((situation) => ({
+                        role: situation.role,
+                        text: situation.text,
+                    })),
+                })),
+            },
+        }),
+        restartToolName: 'besales_test_scenario_generate_get_instructions',
+    }),
+    defineTool({
+        name: 'besales_dialog_script_get',
+        requiredFields: ['agent_id'],
+        schema: z.object({
+            agent_id: uuidSchema,
+        }),
+        createRequest: (input) => ({
+            method: 'GET',
+            path: `/agents/${input.agent_id}/prompt/script`,
+        }),
+    }),
+    defineTool({
+        name: 'besales_dialog_script_update',
+        requiredFields: ['agent_id', 'graph'],
+        schema: z.object({
+            agent_id: uuidSchema,
+            preamble: z.string().optional(),
+            graph: z.object({
+                stages: z.array(z.object({ id: z.string(), name: z.string() })),
+                nodes: z.array(z.object({
+                    id: z.string(),
+                    stageId: z.string(),
+                    title: z.string(),
+                    instruction: z.string(),
+                    leadStateTag: z.string().nullable().optional(),
+                    branchId: z.string(),
+                })),
+                edges: z.array(z.object({
+                    from: z.string(),
+                    to: z.string(),
+                    condition: z.string().nullable().optional(),
+                })),
+            }),
+        }),
+        createRequest: (input) => ({
+            method: 'PUT',
+            path: `/agents/${input.agent_id}/prompt/dialog-script`,
+            body: compactObject({ preamble: input.preamble, graph: input.graph }),
+        }),
+        enhanceResponse: (response) => withInstructions(response, [
+            'Скрипт сохранён в поле (source of truth). Чтобы §6 промпта отразила правку — перегенерируй ' +
+                'промпт: besales_prompt_generate_get_instructions → submit → besales_prompt_finalize.',
+        ]),
+    }),
+];
+//# sourceMappingURL=agent-design.js.map