---
title: Сны
url: https://platform.claude.com/docs/ru/managed-agents/dreams
description: Позвольте Claude поразмышлять над прошлыми сессиями, чтобы упорядочить память агента и выявить новые инсайты.
---

<Tip>
  «Dreaming» (сновидение) — функция в стадии исследовательского предварительного просмотра. [Запросите доступ](https://claude.com/form/claude-managed-agents), чтобы попробовать её.
</Tip>

Агенты записывают данные в свои [хранилища памяти](https://platform.claude.com/docs/ru/managed-agents/memory) (memory stores) в процессе работы, но эти записи локальны и инкрементальны: за множество сессий в хранилище памяти накапливаются дубликаты, противоречия и устаревшие записи.

**Dreams** (сны) позволяют Claude навести в этом порядок. Сон читает существующее хранилище памяти вместе с транскриптами прошлых сессий, а затем создаёт новое, реорганизованное хранилище памяти: дубликаты объединены, устаревшие или противоречивые записи заменены актуальными значениями, а новые инсайты выявлены.

Входное хранилище никогда не изменяется, поэтому вы можете просмотреть результат и отбросить его, если он вам не понравится.

<Note>
  Эндпоинты снов защищены бета-заголовком `dreaming-2026-04-21`; заголовок `managed-agents-2026-04-01` сам по себе не даёт доступа к снам. Примеры для эндпоинтов снов на этой странице отправляют оба заголовка; вызовам сессий и хранилищ памяти нужен только `managed-agents-2026-04-01`. SDK устанавливает их автоматически.
</Note>

## Как это работает

**Сон** (dream) — это асинхронное задание, которое принимает:

* уже существующее **хранилище памяти:** хранилище, которое Claude проверяет, дедуплицирует и реорганизует, и
* от 1 до 100 **сессий:** прошлые транскрипты, в которых Claude ищет закономерности и инсайты, чтобы включить их в результат.

Сон создаёт ещё одно **выходное хранилище памяти**, отдельное от входного. Идентификатор выходного хранилища появляется в массиве `outputs` (csharp, go: `Outputs`) сна вскоре после того, как сон переходит в состояние `running`, — как только рабочий процесс клонирует входное хранилище; сон в состоянии `running` может ненадолго возвращать пустой массив `outputs` (csharp, go: `Outputs`).

## Создание сна

<CodeGroup>
  ```bash cURL
  curl -s https://api.anthropic.com/v1/dreams \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21" \
    -H "content-type: application/json" \
    --data '{
      "inputs": [
        { "type": "memory_store", "memory_store_id": "'"$store_id"'" },
        { "type": "sessions", "session_ids": ["'"$session_a"'", "'"$session_b"'"] }
      ],
      "model": "claude-opus-5-5",
      "instructions": "Focus on coding-style preferences; ignore one-off debugging notes."
    }'
  ```

  ```bash CLI
  ant beta:dreams create <<YAML
  inputs:
    - type: memory_store
      memory_store_id: $store_id
    - type: sessions
      session_ids: [$session_a, $session_b]
  model: claude-opus-5-5
  instructions: Focus on coding-style preferences; ignore one-off debugging notes.
  YAML
  ```

  ```python Python
  dream = client.beta.dreams.create(
      inputs=[
          {"type": "memory_store", "memory_store_id": store_id},
          {"type": "sessions", "session_ids": [session_a, session_b]},
      ],
      model="claude-opus-5-5",
      instructions="Focus on coding-style preferences; ignore one-off debugging notes.",
  )
  print(dream.id)  # drm_01...
  ```

  ```typescript TypeScript
  let dream = await client.beta.dreams.create({
    inputs: [
      { type: "memory_store", memory_store_id: storeId },
      { type: "sessions", session_ids: [sessionA, sessionB] }
    ],
    model: "claude-opus-5-5",
    instructions: "Focus on coding-style preferences; ignore one-off debugging notes."
  });
  console.log(dream.id); // drm_01...
  ```

  ```csharp C#
  var dream = await client.Beta.Dreams.Create(new()
  {
      Inputs =
      [
          new BetaDreamMemoryStoreInput
          {
              Type = BetaDreamMemoryStoreInputType.MemoryStore,
              MemoryStoreID = storeID,
          },
          new BetaDreamSessionsInput
          {
              Type = BetaDreamSessionsInputType.Sessions,
              SessionIds = [sessionA, sessionB],
          },
      ],
      Model = "claude-opus-5-5",
      Instructions = "Focus on coding-style preferences; ignore one-off debugging notes.",
  });
  Console.WriteLine(dream.ID);  // drm_01...
  ```

  ```go Go
  dream, err := client.Beta.Dreams.New(ctx, anthropic.BetaDreamNewParams{
  	Inputs: []anthropic.BetaDreamInputUnionParam{
  		anthropic.BetaDreamInputParamOfMemoryStore(storeID),
  		anthropic.BetaDreamInputParamOfSessions([]string{sessionA, sessionB}),
  	},
  	Model: anthropic.BetaDreamNewParamsModelUnion{
  		OfString: anthropic.String("claude-opus-5-5"),
  	},
  	Instructions: anthropic.String("Focus on coding-style preferences; ignore one-off debugging notes."),
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(dream.ID) // drm_01...
  ```

  ```java Java
  var dream = client.beta().dreams().create(
      DreamCreateParams.builder()
          .addMemoryStoreInput(storeId)
          .addSessionsInput(List.of(sessionA, sessionB))
          .model("claude-opus-5-5")
          .instructions("Focus on coding-style preferences; ignore one-off debugging notes.")
          .build()
  );
  IO.println(dream.id());  // drm_01...
  ```

  ```php PHP
  $dream = $client->beta->dreams->create(
      inputs: [
          ['type' => 'memory_store', 'memory_store_id' => $storeId],
          ['type' => 'sessions', 'session_ids' => [$sessionA, $sessionB]],
      ],
      model: 'claude-opus-5-5',
      instructions: 'Focus on coding-style preferences; ignore one-off debugging notes.',
  );
  echo "{$dream->id}\n"; // drm_01...
  ```

  ```ruby Ruby
  dream = client.beta.dreams.create(
    inputs: [
      {type: "memory_store", memory_store_id: store_id},
      {type: "sessions", session_ids: [session_a, session_b]}
    ],
    model: "claude-opus-5-5",
    instructions: "Focus on coding-style preferences; ignore one-off debugging notes."
  )
  puts dream.id # drm_01...
  ```
</CodeGroup>

Входные данные сновидения включают уже существующее хранилище памяти и массив сессий. Выбранная модель выполняет конвейер сновидения. В период исследовательского предварительного просмотра поддерживаются `claude-opus-5-5`, `claude-fable-5-1`, `claude-opus-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5-5`, `claude-sonnet-5` и `claude-sonnet-4-6`. При желании вы можете передать `instructions` (csharp, go: `Instructions`), чтобы направлять процесс сновидения. См. [Управление с помощью инструкций](https://platform.claude.com/docs/ru/managed-agents/dreams#steer-with-instructions).

Ответ представляет собой полный ресурс `dream` со `status: "pending"`:

```json
{
  "type": "dream",
  "id": "drm_01AbCDefGhIjKlMnOpQrStUv",
  "status": "pending",
  "inputs": [
    { "type": "memory_store", "memory_store_id": "memstore_01Hx..." },
    { "type": "sessions", "session_ids": ["sesn_01...", "sesn_02..."] }
  ],
  "outputs": [],
  "model": { "id": "claude-opus-5-5" },
  "instructions": "Focus on coding-style preferences; ignore one-off debugging notes.",
  "session_id": null,
  "created_at": "2026-04-29T17:04:10Z",
  "ended_at": null,
  "archived_at": null,
  "usage": {
    "input_tokens": 0,
    "output_tokens": 0,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0
  },
  "error": null
}
```

<Tip>
  Если у вас есть только транскрипты сессий и нет существующего хранилища, сначала [создайте пустое хранилище памяти](https://platform.claude.com/docs/ru/managed-agents/memory#create-a-memory-store) и передайте его в качестве входного параметра `memory_store`.
</Tip>

### Управление с помощью инструкций

Необязательное поле `instructions` (csharp, go: `Instructions`) определяет, что синтезирует конвейер сновидения. Оно применяется на протяжении всего конвейера: что читать внимательно, что объединять или отбрасывать и как структурировать выходное хранилище.

Используйте `instructions` (csharp, go: `Instructions`) для высокоуровневых указаний по синтезу, таких как приоритетные области («сосредоточься на предпочтениях в стиле кода»), содержимое, которое нужно сохранить без изменений, или соглашения о выходных данных, которые вы хотите применить ко всему хранилищу. Конвейер — это проход синтеза по входным данным, а не редактор, применяемый к тексту хранилища, поэтому императивные директивы, нацеленные на конкретные строки («замени предложение X на Y», «исправь количество в разделе Z»), как правило, не приводят к изменениям. Чтобы вносить точечные правки в отдельные записи памяти, используйте [Memory Stores API](https://platform.claude.com/docs/ru/managed-agents/memory#view-and-edit-memories) непосредственно для выходного хранилища.

## Отслеживание прогресса

Сны выполняются асинхронно и обычно занимают от нескольких минут до нескольких часов в зависимости от количества входных транскриптов. Опрашивайте сон по идентификатору, чтобы проверить статус:

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/dreams/$dream_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams retrieve --dream-id "$dream_id"
  ```

  ```python Python
  while dream.status in ("pending", "running"):
      time.sleep(10)
      dream = client.beta.dreams.retrieve(dream.id)
      print(f"status={dream.status} input_tokens={dream.usage.input_tokens}")
  ```

  ```typescript TypeScript
  while (dream.status === "pending" || dream.status === "running") {
    await sleep(10_000);
    dream = await client.beta.dreams.retrieve(dream.id);
    console.log(`status=${dream.status} input_tokens=${dream.usage.input_tokens}`);
  }
  ```

  ```csharp C#
  while (dream.Status.Value() is BetaDreamStatus.Pending or BetaDreamStatus.Running)
  {
      await Task.Delay(TimeSpan.FromSeconds(10));
      dream = await client.Beta.Dreams.Retrieve(dream.ID);
      Console.WriteLine($"status={dream.Status.Raw()} input_tokens={dream.Usage.InputTokens}");
  }
  ```

  ```go Go
  for dream.Status == anthropic.BetaDreamStatusPending || dream.Status == anthropic.BetaDreamStatusRunning {
  	time.Sleep(10 * time.Second)
  	dream, err = client.Beta.Dreams.Get(ctx, dream.ID, anthropic.BetaDreamGetParams{})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("status=%s input_tokens=%d\n", dream.Status, dream.Usage.InputTokens)
  }
  ```

  ```java Java
  while (dream.status().equals(BetaDreamStatus.PENDING)
          || dream.status().equals(BetaDreamStatus.RUNNING)) {
      Thread.sleep(10_000);
      dream = client.beta().dreams().retrieve(dream.id());
      IO.println("status=" + dream.status() + " input_tokens=" + dream.usage().inputTokens());
  }
  ```

  ```php PHP
  while (in_array($dream->status, [BetaDreamStatus::PENDING->value, BetaDreamStatus::RUNNING->value], true)) {
      sleep(10);
      $dream = $client->beta->dreams->retrieve($dream->id);
      echo "status={$dream->status} input_tokens={$dream->usage->inputTokens}\n";
  }
  ```

  ```ruby Ruby
  while %i[pending running].include?(dream.status)
    sleep 10
    dream = client.beta.dreams.retrieve(dream.id)
    puts "status=#{dream.status} input_tokens=#{dream.usage.input_tokens}"
  end
  ```
</CodeGroup>

### Жизненный цикл

| `status` (csharp, go: `Status`) | Значение                                                                                                                   |
| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| `pending`                       | Сон успешно создан и поставлен в очередь.                                                                                  |
| `running`                       | Конвейер выполняет обработку. `usage` (csharp, go: `Usage`) обновляется по мере выполнения работы.                         |
| `completed`                     | Успешно завершён. Значение `outputs` (csharp, go: `Outputs`) — это новое хранилище памяти.                                 |
| `failed`                        | Выполнение сновидения завершилось ошибкой. Выходное хранилище памяти остаётся как есть — с тем, что было записано до сбоя. |
| `canceled`                      | Выполнение сновидения отменено. Выходное хранилище памяти остаётся как есть.                                               |

### Наблюдение за работой конвейера

Как только сон переходит в состояние `running`, его поле `session_id` (java: `sessionId`; php: `sessionID`; csharp, go: `SessionID`) указывает на базовую [сессию](https://platform.claude.com/docs/ru/managed-agents/sessions), в которой выполняется конвейер. Вы можете получать [события](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming) этой сессии в режиме потоковой передачи, чтобы в реальном времени наблюдать, что сон читает и записывает. Сессия архивируется (а не удаляется), когда сон достигает конечного состояния, поэтому транскрипт остаётся доступным и после этого.

## Использование результата

Когда `status` (csharp, go: `Status`) достигает значения `completed`, запись `memory_store` в `outputs` (csharp, go: `Outputs`) ссылается на полностью заполненное хранилище. Это обычное хранилище памяти в вашем рабочем пространстве. Просмотрите его с помощью [Memory Stores API](https://platform.claude.com/docs/ru/managed-agents/memory#view-and-edit-memories) или в Console, а затем:

* **Используйте его:** подключите его к будущим сессиям как ресурс `memory_store` вместо входного хранилища памяти (или вместе с ним), либо
* **Отбросьте его:** [удалите хранилище памяти](https://platform.claude.com/docs/ru/api/beta/memory_stores/delete) или [архивируйте хранилище памяти](https://platform.claude.com/docs/ru/api/beta/memory_stores/archive).

<CodeGroup>
  ```bash cURL
  # $output_store_id is the memory_store_id of the completed dream's memory_store output
  curl -s https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "agent": "'"$agent_id"'",
      "environment_id": "'"$environment_id"'",
      "resources": [
        { "type": "memory_store", "memory_store_id": "'"$output_store_id"'" }
      ]
    }'
  ```

  ```bash CLI
  # $output_store_id is the memory_store_id of the completed dream's memory_store output
  ant beta:sessions create <<YAML
  agent: $agent_id
  environment_id: $environment_id
  resources:
    - type: memory_store
      memory_store_id: $output_store_id
  YAML
  ```

  ```python Python
  # После завершения сна вывод содержит перестроенное хранилище памяти
  output_store_id = next(
      output.memory_store_id for output in dream.outputs if output.type == "memory_store"
  )

  session = client.beta.sessions.create(
      agent=agent_id,
      environment_id=environment_id,
      resources=[
          {"type": "memory_store", "memory_store_id": output_store_id},
      ],
  )
  ```

  ```typescript TypeScript
  // После завершения сна вывод содержит перестроенное хранилище памяти
  const output = dream.outputs.find((entry) => entry.type === "memory_store");
  const outputStoreId = output!.memory_store_id;

  await client.beta.sessions.create({
    agent: agentId,
    environment_id: environmentId,
    resources: [{ type: "memory_store", memory_store_id: outputStoreId }]
  });
  ```

  ```csharp C#
  var output = dream.Outputs.FirstOrDefault(entry => entry.Type == "memory_store");
  if (output is { MemoryStoreID: var outputStoreID })
  {
      await client.Beta.Sessions.Create(new()
      {
          Agent = agentID,
          EnvironmentID = environmentID,
          Resources =
          [
              new BetaManagedAgentsMemoryStoreResourceParam
              {
                  Type = BetaManagedAgentsMemoryStoreResourceParamType.MemoryStore,
                  MemoryStoreID = outputStoreID,
              },
          ],
      });
  }
  ```

  ```go Go
  for _, output := range dream.Outputs {
  	if output.Type != "memory_store" {
  		continue
  	}
  	outputStoreID := output.MemoryStoreID

  	session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  		Agent: anthropic.BetaSessionNewParamsAgentUnion{
  			OfString: anthropic.String(agentID),
  		},
  		EnvironmentID: environmentID,
  		Resources: []anthropic.BetaSessionNewParamsResourceUnion{{
  			OfMemoryStore: &anthropic.BetaManagedAgentsMemoryStoreResourceParam{
  				Type:          anthropic.BetaManagedAgentsMemoryStoreResourceParamTypeMemoryStore,
  				MemoryStoreID: outputStoreID,
  			},
  		}},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(session.ID)
  	break
  }
  ```

  ```java Java
  var output = dream.outputs().stream()
      .filter(entry -> entry.type().equals(BetaDreamOutput.Type.MEMORY_STORE))
      .findFirst();
  if (output.isPresent()) {
      var outputStoreId = output.get().memoryStoreId();

      var session = client.beta().sessions().create(
          SessionCreateParams.builder()
              .agent(agentId)
              .environmentId(environmentId)
              .addMemoryStoreResource(outputStoreId)
              .build()
      );
  }
  ```

  ```php PHP
  $matches = array_filter($dream->outputs, fn($output) => $output->type === 'memory_store');
  $output = $matches ? reset($matches) : null;
  if ($output !== null) {
      $session = $client->beta->sessions->create(
          agent: $agentId,
          environmentID: $environmentId,
          resources: [
              ['type' => 'memory_store', 'memory_store_id' => $output->memoryStoreID],
          ],
      );
  }
  ```

  ```ruby Ruby
  output = dream.outputs.find { it.type == :memory_store }
  if output
    client.beta.sessions.create(
      agent: agent_id,
      environment_id: environment_id,
      resources: [
        {type: "memory_store", memory_store_id: output.memory_store_id}
      ]
    )
  end
  ```
</CodeGroup>

Сам сон никогда не удаляет и не изменяет свои входные данные. При `failed` или `canceled` выходное хранилище сохраняется с частичным содержимым, чтобы вы могли изучить, что было создано до остановки; очистите его через Memory Stores API, если оно вам не нужно.

<Warning>
  Пока сон находится в состоянии `pending` или `running`, защита с кодом 400 применяется к архивированию самого сна, а не его хранилищ. Архивирование или удаление *входного* хранилища памяти во время выполнения (или удаление входной сессии) приведёт к сбою сна с ошибкой `input_memory_store_unavailable` или `input_session_unavailable`.
</Warning>

## Отмена сна

Отмена немедленно переводит сон из состояния `pending` или `running` в `canceled`. Отмена уже отменённого (`canceled`) сна — идемпотентная операция без эффекта; отмена сна в состоянии `completed` или `failed` возвращает 400.

<Note>
  После отмены поля `usage` (csharp, go: `Usage`) сна могут продолжать обновляться в течение нескольких секунд, пока завершается уже выполняющаяся работа. Если вам нужны итоговые значения, опрашивайте сон, пока `usage` (csharp, go: `Usage`) не стабилизируется.
</Note>

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/dreams/$dream_id/cancel" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams cancel --dream-id "$dream_id"
  ```

  ```python Python
  client.beta.dreams.cancel(dream.id)
  ```

  ```typescript TypeScript
  await client.beta.dreams.cancel(dream.id);
  ```

  ```csharp C#
  await client.Beta.Dreams.Cancel(dream.ID);
  ```

  ```go Go
  dream, err = client.Beta.Dreams.Cancel(ctx, dream.ID, anthropic.BetaDreamCancelParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().dreams().cancel(dream.id());
  ```

  ```php PHP
  $client->beta->dreams->cancel($dream->id);
  ```

  ```ruby Ruby
  client.beta.dreams.cancel(dream.id)
  ```
</CodeGroup>

## Архивирование сна

Архивирование устанавливает `archived_at` (java, php: `archivedAt`; csharp, go: `ArchivedAt`) для сна, достигшего конечного состояния (`completed`, `failed` или `canceled`); `status` (csharp, go: `Status`) остаётся без изменений. Заархивированные сны исключаются из ответов списка по умолчанию, но остаются доступными для чтения по идентификатору. Архивирование уже заархивированного сна — идемпотентная операция без эффекта. Архивирование сна в состоянии `pending` или `running` возвращает 400; сначала отмените его. Разархивирование не предусмотрено.

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/dreams/$dream_id/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams archive --dream-id "$dream_id"
  ```

  ```python Python
  client.beta.dreams.archive(dream.id)
  ```

  ```typescript TypeScript
  await client.beta.dreams.archive(dream.id);
  ```

  ```csharp C#
  await client.Beta.Dreams.Archive(dream.ID);
  ```

  ```go Go
  dream, err = client.Beta.Dreams.Archive(ctx, dream.ID, anthropic.BetaDreamArchiveParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().dreams().archive(dream.id());
  ```

  ```php PHP
  $client->beta->dreams->archive($dream->id);
  ```

  ```ruby Ruby
  client.beta.dreams.archive(dream.id)
  ```
</CodeGroup>

Архивирование сна не затрагивает его выходное хранилище памяти; управляйте им отдельно через [Memory Stores API](https://platform.claude.com/docs/ru/managed-agents/memory#view-and-edit-memories).

## Список снов

Возвращает все незаархивированные сны в рабочем пространстве, начиная с самых новых. Используйте `limit` (csharp, go: `Limit`) (по умолчанию 20, максимум 100) и курсор `page` (csharp, go: `Page`) для постраничной навигации. Установите `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) в значение `true`, чтобы включить заархивированные сны.

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/dreams?limit=20" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams list --limit 20
  ```

  ```python Python
  for listed_dream in client.beta.dreams.list(limit=20):
      print(listed_dream.id, listed_dream.status)
  ```

  ```typescript TypeScript
  for await (const listedDream of client.beta.dreams.list({ limit: 20 })) {
    console.log(listedDream.id, listedDream.status);
  }
  ```

  ```csharp C#
  var page = await client.Beta.Dreams.List(new() { Limit = 20 });
  await foreach (var listed in page.Paginate())
  {
      Console.WriteLine($"{listed.ID} {listed.Status.Raw()}");
  }
  ```

  ```go Go
  dreams := client.Beta.Dreams.ListAutoPaging(ctx, anthropic.BetaDreamListParams{
  	Limit: anthropic.Int(20),
  })
  for dreams.Next() {
  	listed := dreams.Current()
  	fmt.Println(listed.ID, listed.Status)
  }
  if err := dreams.Err(); err != nil {
  	panic(err)
  }
  ```

  ```java Java
  for (var listedDream : client.beta().dreams().list(
      DreamListParams.builder().limit(20).build()
  ).autoPager()) {
      IO.println(listedDream.id() + " " + listedDream.status());
  }
  ```

  ```php PHP
  foreach ($client->beta->dreams->list(limit: 20)->pagingEachItem() as $dream) {
      echo "{$dream->id} {$dream->status}\n";
  }
  ```

  ```ruby Ruby
  client.beta.dreams.list(limit: 20).auto_paging_each do
    puts "#{it.id} #{it.status}"
  end
  ```
</CodeGroup>

## Ошибки

Ниже приведён неполный список возможных ошибок сновидения.

| `error.type`                      | Когда возникает                                                                            |
| --------------------------------- | ------------------------------------------------------------------------------------------ |
| `timeout`                         | Конвейер превысил свой бюджет времени выполнения.                                          |
| `internal_error`                  | Неклассифицированный сбой конвейера.                                                       |
| `memory_store_org_limit_exceeded` | Ваша организация достигла лимита хранилищ памяти, пока конвейер выделял рабочее хранилище. |
| `input_memory_store_too_large`    | Входное хранилище памяти превышает ограничение конвейера по размеру.                       |
| `input_memory_store_unavailable`  | Входное хранилище памяти было архивировано или удалено после создания сна.                 |
| `input_session_unavailable`       | Входная сессия была удалена после создания сна.                                            |

## Тарификация

Сны оплачиваются по стандартным тарифам API за токены для выбранной вами модели; `usage` (csharp, go: `Usage`) в ресурсе сообщает точные итоговые значения. Стоимость растёт примерно линейно в зависимости от количества и длины входных сессий. Начните с небольшого пакета сессий и увеличивайте масштаб, когда качество упорядочивания вас устроит.

## Ограничения

| Ограничение                                       | Значение                                                                                                                                                                    |
| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Сессий на один сон                                | 100                                                                                                                                                                         |
| Длина `instructions` (csharp, go: `Instructions`) | 4 096 символов                                                                                                                                                              |
| Поддерживаемые модели                             | `claude-opus-5-5`, `claude-fable-5-1`, `claude-opus-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5-5`, `claude-sonnet-5`, `claude-sonnet-4-6` |

Пока эта функция находится в стадии исследовательского предварительного просмотра, к созданию снов применяются ограничения скорости по умолчанию. [Обратитесь в службу поддержки](https://support.claude.com), если вам нужны более высокие лимиты.