Claude Code SDK

claude -p "Анализировать производительность системы" \
  --append-system-prompt "Вы инженер по производительности" \
  --allowedTools "Bash,Read,WebSearch" \
  --permission-mode acceptEdits \
  --cwd /path/to/project

import { query } from "@anthropic-ai/claude-code";

for await (const message of query({
  prompt: "Анализировать производительность системы",
  abortController: new AbortController(),
  options: {
    maxTurns: 5,
    systemPrompt: "Вы инженер по производительности",
    allowedTools: ["Bash", "Read", "WebSearch"]
  }
})) {
  if (message.type === "result") {
    console.log(message.result);
  }
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def main():
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Вы инженер по производительности",
            allowed_tools=["Bash", "Read", "WebSearch"],
            max_turns=5
        )
    ) as client:
        await client.query("Анализировать производительность системы")
        
        # Потоковые ответы
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)

# Запуск как скрипт
asyncio.run(main())

# Или в IPython/Jupyter: await main()

from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async with ClaudeSDKClient() as client:
    # Текстовое сообщение
    await client.query("Проанализируйте этот код на проблемы безопасности")
    
    # Сообщение со ссылкой на изображение (изображение будет прочитано инструментом Read Claude)
    await client.query("Объясните, что показано на screenshot.png")
    
    # Несколько сообщений подряд
    messages = [
        "Сначала проанализируйте диаграмму архитектуры в diagram.png",
        "Теперь предложите улучшения на основе диаграммы",
        "Наконец, сгенерируйте код реализации"
    ]
    
    for msg in messages:
        await client.query(msg)
        async for response in client.receive_response():
            # Обработайте каждый ответ
            pass

# SDK обрабатывает файлы изображений через встроенный инструмент Read Claude
# Поддерживаемые форматы: PNG, JPG, PDF и другие распространенные форматы

from claude_code_sdk import query, ClaudeCodeOptions

async for message in query(
    prompt="Анализировать производительность системы",
    options=ClaudeCodeOptions(system_prompt="Вы инженер по производительности")
):
    if type(message).__name__ == "ResultMessage":
        print(message.result)

# Продолжить самый последний разговор
claude --continue "Теперь рефакторите это для лучшей производительности"

# Возобновить конкретный разговор по ID сессии
claude --resume 550e8400-e29b-41d4-a716-446655440000 "Обновите тесты"

# Возобновить в неинтерактивном режиме
claude --resume 550e8400-e29b-41d4-a716-446655440000 "Исправьте все проблемы линтинга" --no-interactive

import { query } from "@anthropic-ai/claude-code";

// Продолжить самый последний разговор
for await (const message of query({
  prompt: "Теперь рефакторите это для лучшей производительности",
  options: { continueSession: true }
})) {
  if (message.type === "result") console.log(message.result);
}

// Возобновить конкретную сессию
for await (const message of query({
  prompt: "Обновите тесты",
  options: { 
    resumeSessionId: "550e8400-e29b-41d4-a716-446655440000",
    maxTurns: 3
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions, query

# Метод 1: Использование ClaudeSDKClient для постоянных разговоров
async def multi_turn_conversation():
    async with ClaudeSDKClient() as client:
        # Первый запрос
        await client.query("Давайте рефакторим модуль платежей")
        async for msg in client.receive_response():
            # Обработайте первый ответ
            pass
        
        # Продолжите в той же сессии
        await client.query("Теперь добавьте комплексную обработку ошибок")
        async for msg in client.receive_response():
            # Обработайте продолжение
            pass
        
        # Контекст разговора поддерживается на протяжении всего времени

# Метод 2: Использование функции query с управлением сессиями
async def resume_session():
    # Продолжить самый последний разговор
    async for message in query(
        prompt="Теперь рефакторите это для лучшей производительности",
        options=ClaudeCodeOptions(continue_conversation=True)
    ):
        if type(message).__name__ == "ResultMessage":
            print(message.result)

    # Возобновить конкретную сессию
    async for message in query(
        prompt="Обновите тесты", 
        options=ClaudeCodeOptions(
            resume="550e8400-e29b-41d4-a716-446655440000",
            max_turns=3
        )
    ):
        if type(message).__name__ == "ResultMessage":
            print(message.result)

# Запустите примеры
asyncio.run(multi_turn_conversation())

claude -p "Проверьте этот код" --permission-mode plan

import { query } from "@anthropic-ai/claude-code";

for await (const message of query({
  prompt: "Ваш промпт здесь",
  options: {
    permissionMode: 'plan'
  }
})) {
  if (message.type === "result") {
    console.log(message.result);
  }
}

from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async with ClaudeSDKClient(
    options=ClaudeCodeOptions(permission_mode='plan')
) as client:
    await client.query("Ваш промпт здесь")

# Агент реагирования на инциденты SRE
claude -p "API не работает, исследуйте" \
  --append-system-prompt "Вы эксперт SRE. Диагностируйте проблемы систематически и предоставляйте практические решения."

# Агент проверки юридических документов  
claude -p "Проверьте этот контракт" \
  --append-system-prompt "Вы корпоративный юрист. Выявляйте риски, предлагайте улучшения и обеспечивайте соответствие требованиям."

# Добавить к системному промпту по умолчанию
claude -p "Рефакторите эту функцию" \
  --append-system-prompt "Всегда включайте комплексную обработку ошибок и модульные тесты."

import { query } from "@anthropic-ai/claude-code";

// Агент реагирования на инциденты SRE
for await (const message of query({
  prompt: "API не работает, исследуйте",
  options: {
    systemPrompt: "Вы эксперт SRE. Диагностируйте проблемы систематически и предоставляйте практические решения.",
    maxTurns: 3
  }
})) {
  if (message.type === "result") console.log(message.result);
}

// Добавить к системному промпту по умолчанию
for await (const message of query({
  prompt: "Рефакторите эту функцию",
  options: {
    appendSystemPrompt: "Всегда включайте комплексную обработку ошибок и модульные тесты.",
    maxTurns: 2
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def specialized_agents():
    # Агент реагирования на инциденты SRE с потоковой передачей
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Вы эксперт SRE. Диагностируйте проблемы систематически и предоставляйте практические решения.",
            max_turns=3
        )
    ) as sre_agent:
        await sre_agent.query("API не работает, исследуйте")
        
        # Потоковая передача процесса диагностики
        async for message in sre_agent.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
    
    # Агент юридической проверки с пользовательским промптом
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            append_system_prompt="Всегда включайте комплексную обработку ошибок и модульные тесты.",
            max_turns=2
        )
    ) as dev_agent:
        await dev_agent.query("Рефакторите эту функцию")
        
        # Собрать полный ответ
        full_response = []
        async for message in dev_agent.receive_response():
            if type(message).__name__ == "ResultMessage":
                print(message.result)

asyncio.run(specialized_agents())

# Агент SRE с инструментами мониторинга
claude -p "Исследуйте сбой платежного сервиса" \
  --mcp-config sre-tools.json \
  --allowedTools "mcp__datadog,mcp__pagerduty,mcp__kubernetes" \
  --append-system-prompt "Вы SRE. Используйте данные мониторинга для диагностики проблем."

# Агент службы поддержки клиентов с доступом к CRM
claude -p "Помогите решить тикет клиента #12345" \
  --mcp-config support-tools.json \
  --allowedTools "mcp__zendesk,mcp__stripe,mcp__user_db" \
  --append-system-prompt "Вы специалист технической поддержки."

import { query } from "@anthropic-ai/claude-code";

// Агент SRE с инструментами мониторинга
for await (const message of query({
  prompt: "Исследуйте сбой платежного сервиса",
  options: {
    mcpConfig: "sre-tools.json",
    allowedTools: ["mcp__datadog", "mcp__pagerduty", "mcp__kubernetes"],
    systemPrompt: "Вы SRE. Используйте данные мониторинга для диагностики проблем.",
    maxTurns: 4
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def mcp_enabled_agent():
    # Юридический агент с доступом к документам и потоковой передачей
    # Примечание: Настройте ваши MCP серверы по мере необходимости
    mcp_servers = {
        # Пример конфигурации - раскомментируйте и настройте по мере необходимости:
        # "docusign": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-docusign"],
        #     "env": {"API_KEY": "your-key"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            mcp_servers=mcp_servers,
            allowed_tools=["mcp__docusign", "mcp__compliance_db"],
            system_prompt="Вы корпоративный юрист, специализирующийся на проверке контрактов.",
            max_turns=4
        )
    ) as client:
        await client.query("Проверьте этот контракт на риски соответствия требованиям")
        
        # Мониторинг использования инструментов и ответов
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):
                        if block.type == 'tool_use':
                            print(f"\n[Использование инструмента: {block.name}]\n")
                        elif hasattr(block, 'text'):
                            print(block.text, end='', flush=True)
                    elif hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
            
            if type(message).__name__ == "ResultMessage":
                print(f"\n\nПроверка завершена. Общая стоимость: ${message.total_cost_usd:.4f}")

asyncio.run(mcp_enabled_agent())

# Использование с конфигурацией вашего MCP сервера
claude -p "Проанализируйте и исправьте проблемы безопасности" \
  --permission-prompt-tool mcp__security__approval_prompt \
  --mcp-config security-tools.json \
  --allowedTools "Read,Grep" \
  --disallowedTools "Bash(rm*),Write"

# С пользовательскими правилами разрешений
claude -p "Рефакторите кодовую базу" \
  --permission-prompt-tool mcp__custom__permission_check \
  --mcp-config custom-config.json \
  --output-format json

const server = new McpServer({
  name: "Test permission prompt MCP Server",
  version: "0.0.1",
});

server.tool(
  "approval_prompt",
  'Симулировать проверку разрешений - одобрить, если входные данные содержат "allow", иначе отклонить',
  {
    tool_name: z.string().describe("Имя инструмента, запрашивающего разрешение"),
    input: z.object({}).passthrough().describe("Входные данные для инструмента"),
    tool_use_id: z.string().optional().describe("Уникальный ID запроса использования инструмента"),
  },
  async ({ tool_name, input }) => {
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(
            JSON.stringify(input).includes("allow")
              ? {
                  behavior: "allow",
                  updatedInput: input,
                }
              : {
                  behavior: "deny",
                  message: "Разрешение отклонено инструментом test approval_prompt",
                }
          ),
        },
      ],
    };
  }
);

// Использование в SDK
import { query } from "@anthropic-ai/claude-code";

for await (const message of query({
  prompt: "Проанализируйте кодовую базу",
  options: {
    permissionPromptTool: "mcp__test-server__approval_prompt",
    mcpConfig: "my-config.json",
    allowedTools: ["Read", "Grep"]
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def use_permission_prompt():
    """Пример использования пользовательского инструмента промпта разрешений"""
    
    # Конфигурация MCP сервера
    mcp_servers = {
        # Пример конфигурации - раскомментируйте и настройте по мере необходимости:
        # "security": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-security"],
        #     "env": {"API_KEY": "your-key"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            permission_prompt_tool_name="mcp__security__approval_prompt",  # Изменено с permission_prompt_tool
            mcp_servers=mcp_servers,
            allowed_tools=["Read", "Grep"],
            disallowed_tools=["Bash(rm*)", "Write"],
            system_prompt="Вы аудитор безопасности"
        )
    ) as client:
        await client.query("Проанализируйте и исправьте проблемы безопасности")
        
        # Мониторинг использования инструментов и разрешений
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):  # Добавлена проверка атрибута 'type'
                        if block.type == 'tool_use':
                            print(f"[Инструмент: {block.name}] ", end='')
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
            
            # Проверка отклонений разрешений в сообщениях об ошибках
            if type(message).__name__ == "ErrorMessage":
                if hasattr(message, 'error') and "Permission denied" in str(message.error):
                    print(f"\n⚠️ Разрешение отклонено: {message.error}")

# Пример реализации MCP сервера (Python)
# Это было бы в коде вашего MCP сервера
async def approval_prompt(tool_name: str, input: dict, tool_use_id: str = None):
    """Пользовательский обработчик промпта разрешений"""
    # Ваша пользовательская логика здесь
    if "allow" in str(input):
        return json.dumps({
            "behavior": "allow",
            "updatedInput": input
        })
    else:
        return json.dumps({
            "behavior": "deny",
            "message": f"Разрешение отклонено для {tool_name}"
        })

asyncio.run(use_permission_prompt())

claude -p "Объясните файл src/components/Header.tsx"
# Вывод: Это React компонент, показывающий...

// Текстовый вывод по умолчанию
for await (const message of query({
  prompt: "Объясните файл src/components/Header.tsx"
})) {
  if (message.type === "result") {
    console.log(message.result);
    // Вывод: Это React компонент, показывающий...
  }
}

# Текстовый вывод по умолчанию с потоковой передачей
async with ClaudeSDKClient() as client:
    await client.query("Объясните файл src/components/Header.tsx")
    
    # Потоковая передача текста по мере поступления
    async for message in client.receive_response():
        if hasattr(message, 'content'):
            for block in message.content:
                if hasattr(block, 'text'):
                    print(block.text, end='', flush=True)
                    # Вывод потоком в реальном времени: Это React компонент, показывающий...

claude -p "Как работает слой данных?" --output-format json

// Собрать все сообщения для JSON-подобного доступа
const messages = [];
for await (const message of query({
  prompt: "Как работает слой данных?"
})) {
  messages.push(message);
}

// Доступ к сообщению результата с метаданными
const result = messages.find(m => m.type === "result");
console.log({
  result: result.result,
  cost: result.total_cost_usd,
  duration: result.duration_ms
});

# Собрать все сообщения с метаданными
async with ClaudeSDKClient() as client:
    await client.query("Как работает слой данных?")
    
    messages = []
    result_data = None
    
    async for message in client.receive_messages():
        messages.append(message)
        
        # Захватить сообщение результата с метаданными
        if type(message).__name__ == "ResultMessage":
            result_data = {
                "result": message.result,
                "cost": message.total_cost_usd,
                "duration": message.duration_ms,
                "num_turns": message.num_turns,
                "session_id": message.session_id
            }
            break
    
    print(result_data)

# Прямой аргумент
claude -p "Объясните этот код"

# Из stdin
echo "Объясните этот код" | claude -p

// Прямой промпт
for await (const message of query({
  prompt: "Объясните этот код"
})) {
  if (message.type === "result") console.log(message.result);
}

// Из переменной
const userInput = "Объясните этот код";
for await (const message of query({ prompt: userInput })) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient

async def process_inputs():
    async with ClaudeSDKClient() as client:
        # Текстовый ввод
        await client.query("Объясните этот код")
        async for message in client.receive_response():
            # Обработайте потоковый ответ
            pass
        
        # Ввод изображения (Claude автоматически использует инструмент Read)
        await client.query("Что на этой диаграмме? screenshot.png")
        async for message in client.receive_response():
            # Обработайте анализ изображения
            pass
        
        # Несколько входных данных со смешанным контентом
        inputs = [
            "Проанализируйте архитектуру в diagram.png",
            "Сравните ее с лучшими практиками",
            "Сгенерируйте улучшенную версию"
        ]
        
        for prompt in inputs:
            await client.query(prompt)
            async for message in client.receive_response():
                # Обработайте каждый ответ
                pass

asyncio.run(process_inputs())

#!/bin/bash

# Автоматизированный агент реагирования на инциденты
investigate_incident() {
    local incident_description="$1"
    local severity="${2:-medium}"
    
    claude -p "Инцидент: $incident_description (Серьезность: $severity)" \
      --append-system-prompt "Вы эксперт SRE. Диагностируйте проблему, оцените воздействие и предоставьте немедленные пункты действий." \
      --output-format json \
      --allowedTools "Bash,Read,WebSearch,mcp__datadog" \
      --mcp-config monitoring-tools.json
}

# Использование
investigate_incident "Payment API возвращает ошибки 500" "high"

import { query } from "@anthropic-ai/claude-code";

// Автоматизированный агент реагирования на инциденты
async function investigateIncident(
  incidentDescription: string, 
  severity = "medium"
) {
  const messages = [];
  
  for await (const message of query({
    prompt: `Инцидент: ${incidentDescription} (Серьезность: ${severity})`,
    options: {
      systemPrompt: "Вы эксперт SRE. Диагностируйте проблему, оцените воздействие и предоставьте немедленные пункты действий.",
      maxTurns: 6,
      allowedTools: ["Bash", "Read", "WebSearch", "mcp__datadog"],
      mcpConfig: "monitoring-tools.json"
    }
  })) {
    messages.push(message);
  }
  
  return messages.find(m => m.type === "result");
}

// Использование
const result = await investigateIncident("Payment API возвращает ошибки 500", "high");
console.log(result.result);

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def investigate_incident(incident_description: str, severity: str = "medium"):
    """Автоматизированный агент реагирования на инциденты с потоковой передачей в реальном времени"""
    
    # Конфигурация MCP сервера для инструментов мониторинга
    mcp_servers = {
        # Пример конфигурации - раскомментируйте и настройте по мере необходимости:
        # "datadog": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-datadog"],
        #     "env": {"API_KEY": "your-datadog-key", "APP_KEY": "your-app-key"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Вы эксперт SRE. Диагностируйте проблему, оцените воздействие и предоставьте немедленные пункты действий.",
            max_turns=6,
            allowed_tools=["Bash", "Read", "WebSearch", "mcp__datadog"],
            mcp_servers=mcp_servers
        )
    ) as client:
        # Отправьте детали инцидента
        prompt = f"Инцидент: {incident_description} (Серьезность: {severity})"
        print(f"🚨 Исследование: {prompt}\n")
        await client.query(prompt)
        
        # Потоковая передача процесса исследования
        investigation_log = []
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):
                        if block.type == 'tool_use':
                            print(f"[{block.name}] ", end='')
                    if hasattr(block, 'text'):
                        text = block.text
                        print(text, end='', flush=True)
                        investigation_log.append(text)
            
            # Захватить финальный результат
            if type(message).__name__ == "ResultMessage":
                return {
                    'analysis': ''.join(investigation_log),
                    'cost': message.total_cost_usd,
                    'duration_ms': message.duration_ms
                }

# Использование
result = await investigate_incident("Payment API возвращает ошибки 500", "high")
print(f"\n\nИсследование завершено. Стоимость: ${result['cost']:.4f}")

# Агент аудита безопасности для pull request'ов
audit_pr() {
    local pr_number="$1"
    
    gh pr diff "$pr_number" | claude -p \
      --append-system-prompt "Вы инженер по безопасности. Проверьте этот PR на уязвимости, небезопасные паттерны и проблемы соответствия требованиям." \
      --output-format json \
      --allowedTools "Read,Grep,WebSearch"
}

# Использование и сохранение в файл
audit_pr 123 > security-report.json

import { query } from "@anthropic-ai/claude-code";
import { execSync } from "child_process";

async function auditPR(prNumber: number) {
  // Получить diff PR
  const prDiff = execSync(`gh pr diff ${prNumber}`, { encoding: 'utf8' });
  
  const messages = [];
  for await (const message of query({
    prompt: prDiff,
    options: {
      systemPrompt: "Вы инженер по безопасности. Проверьте этот PR на уязвимости, небезопасные паттерны и проблемы соответствия требованиям.",
      maxTurns: 3,
      allowedTools: ["Read", "Grep", "WebSearch"]
    }
  })) {
    messages.push(message);
  }
  
  return messages.find(m => m.type === "result");
}

// Использование
const report = await auditPR(123);
console.log(JSON.stringify(report, null, 2));

import subprocess
import asyncio
import json
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def audit_pr(pr_number: int):
    """Агент аудита безопасности для pull request'ов с потоковой обратной связью"""
    # Получить diff PR
    pr_diff = subprocess.check_output(
        ["gh", "pr", "diff", str(pr_number)], 
        text=True
    )
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Вы инженер по безопасности. Проверьте этот PR на уязвимости, небезопасные паттерны и проблемы соответствия требованиям.",
            max_turns=3,
            allowed_tools=["Read", "Grep", "WebSearch"]
        )
    ) as client:
        print(f"🔍 Аудит PR #{pr_number}\n")
        await client.query(pr_diff)
        
        findings = []
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        # Потоковая передача находок по мере их обнаружения
                        print(block.text, end='', flush=True)
                        findings.append(block.text)
            
            if type(message).__name__ == "ResultMessage":
                return {
                    'pr_number': pr_number,
                    'findings': ''.join(findings),
                    'metadata': {
                        'cost': message.total_cost_usd,
                        'duration': message.duration_ms,
                        'severity': 'high' if 'vulnerability' in ''.join(findings).lower() else 'medium'
                    }
                }

# Использование
report = await audit_pr(123)
print(f"\n\nАудит завершен. Серьезность: {report['metadata']['severity']}")
print(json.dumps(report, indent=2))

# Проверка юридических документов с постоянством сессии
session_id=$(claude -p "Начать сессию юридической проверки" --output-format json | jq -r '.session_id')

# Проверить контракт в несколько шагов
claude -p --resume "$session_id" "Проверьте contract.pdf на статьи об ответственности"
claude -p --resume "$session_id" "Проверьте соответствие требованиям GDPR" 
claude -p --resume "$session_id" "Сгенерируйте исполнительное резюме рисков"

import { query } from "@anthropic-ai/claude-code";

async function legalReview() {
  // Начать сессию юридической проверки
  let sessionId: string;
  
  for await (const message of query({
    prompt: "Начать сессию юридической проверки",
    options: { maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "init") {
      sessionId = message.session_id;
    }
  }
  
  // Многошаговая проверка с использованием той же сессии
  const steps = [
    "Проверьте contract.pdf на статьи об ответственности",
    "Проверьте соответствие требованиям GDPR",
    "Сгенерируйте исполнительное резюме рисков"
  ];
  
  for (const step of steps) {
    for await (const message of query({
      prompt: step,
      options: { resumeSessionId: sessionId, maxTurns: 2 }
    })) {
      if (message.type === "result") {
        console.log(`Шаг: ${step}`);
        console.log(message.result);
      }
    }
  }
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def legal_review():
    """Проверка юридических документов с постоянной сессией и потоковой передачей"""
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="Вы корпоративный юрист. Предоставляйте подробный юридический анализ.",
            max_turns=2
        )
    ) as client:
        # Многошаговая проверка в той же сессии
        steps = [
            "Проверьте contract.pdf на статьи об ответственности",
            "Проверьте соответствие требованиям GDPR", 
            "Сгенерируйте исполнительное резюме рисков"
        ]
        
        review_results = []
        
        for step in steps:
            print(f"\n📋 {step}\n")
            await client.query(step)
            
            step_result = []
            async for message in client.receive_response():
                if hasattr(message, 'content'):
                    for block in message.content:
                        if hasattr(block, 'text'):
                            text = block.text
                            print(text, end='', flush=True)
                            step_result.append(text)
                
                if type(message).__name__ == "ResultMessage":
                    review_results.append({
                        'step': step,
                        'analysis': ''.join(step_result),
                        'cost': message.total_cost_usd
                    })
        
        # Резюме
        total_cost = sum(r['cost'] for r in review_results)
        print(f"\n\n✅ Юридическая проверка завершена. Общая стоимость: ${total_cost:.4f}")
        return review_results

# Использование
results = await legal_review()