---
title: Операции с сессиями
url: https://platform.claude.com/docs/ru/managed-agents/session-operations
description: Получение, перечисление, обновление, архивирование и удаление сессий Claude Managed Agents.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

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

## Статусы сессий

Сессии проходят через следующие статусы. Жизненный цикл сессии описан в разделе [Запуск сессии](https://platform.claude.com/docs/ru/managed-agents/sessions).

| Статус         | Описание                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `idle`         | Агент ожидает ввода, включая сообщения пользователя или подтверждения инструментов. Сессии, созданные без `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`), начинаются в статусе `idle`. Сессия может находиться в статусе `idle`, пока [запуск рабочего процесса](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#while-a-run-is-open) ещё открыт, поэтому сам по себе статус `idle` не означает, что работа завершена. См. раздел [Как узнать, что работа выполнена](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#know-when-the-work-is-done). |
| `running`      | Агент активно выполняет работу.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `rescheduling` | Произошла временная ошибка, выполняется автоматическая повторная попытка.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `terminated`   | Сессия завершена — либо из-за неустранимой ошибки, либо потому, что она была архивирована. Сессия, завершившая свою работу, переходит в статус `idle`, а не `terminated`.                                                                                                                                                                                                                                                                                                                                                                                                                                       |

## Обновление конфигурации агента

Вы можете обновить `agent.tools` (csharp, go: `Agent.Tools`) и `agent.mcp_servers` (java, php: `agent.mcpServers`; csharp: `Agent.McpServers`; go: `Agent.MCPServers`) сессии, включая политики разрешений и веб-настройки отдельных инструментов, такие как [фильтры доменов](https://platform.claude.com/docs/ru/managed-agents/tools-web-restrictions#change-the-lists-mid-session), прямо во время сессии без создания новой версии агента. Обновления действуют только в пределах сессии и не распространяются обратно на базовый агент. Обновлённые `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) и `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) применяются до конца сессии.

После создания сессии можно изменить только `tools` (csharp, go: `Tools`) и `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) агента. Чтобы запустить сессию со значениями `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`) или `skills` (csharp, go: `Skills`), отличными от значений агента, используйте [переопределения конфигурации агента](https://platform.claude.com/docs/ru/managed-agents/sessions#override-agent-configuration-for-a-session) при создании сессии. Конфигурацию модели агента, включая закрепление [`inference_geo`](https://platform.claude.com/docs/ru/manage-claude/data-residency), также нельзя изменить во время сессии: задайте закрепление при сохранении агента либо задайте или сбросьте его для отдельной сессии с помощью переопределения `model` (csharp, go: `Model`) при её создании. Настроенное поле `system` (csharp, go: `System`; ruby: `system_`) агента остаётся неизменным на протяжении всего времени жизни сессии. На моделях, которые это поддерживают, вы всё же можете добавлять указания системного уровня во время сессии, отправляя [событие `system.message`](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#send-system-messages).

Обновление `tools` (csharp, go: `Tools`) или `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) работает как полная замена: переданный массив становится новым значением. Чтобы сохранить существующие записи, выполните `GET` для сессии, измените массив и отправьте его обратно через `POST`.

Для обновления агента сессия должна находиться в статусе `idle`. Чтобы обновить агента, пока сессия выполняется, отправьте отдельно [событие `user.interrupt`](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#interrupt-the-agent) и дождитесь, пока сессия перейдёт в статус `idle`. Если открыт [запуск рабочего процесса](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#while-a-run-is-open) — выполняется он или приостановлен, — обновление возвращает ошибку 400, даже если сессия находится в статусе `idle`. Прерывание не завершает запуск, поэтому обновление по-прежнему завершается ошибкой после прерывания сессии. Отправьте `user.message`, в котором [попросите агента остановить его запуски](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), или дождитесь завершения всех запусков.

<CodeGroup>
  ```bash cURL
  curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
    -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" \
    -d '{
      "agent": {
        "tools": [
          {"type": "agent_toolset_20260401"},
          {"type": "mcp_toolset", "mcp_server_name": "linear"}
        ],
        "mcp_servers": [
          {"type": "url", "name": "linear", "url": "https://mcp.linear.app/sse"}
        ]
      }
    }'
  ```

  ```bash CLI
  ant beta:sessions update --session-id "$SESSION_ID" <<'YAML'
  agent:
    tools:
      - type: agent_toolset_20260401
      - type: mcp_toolset
        mcp_server_name: linear
    mcp_servers:
      - type: url
        name: linear
        url: https://mcp.linear.app/sse
  YAML
  ```

  ```python Python
  client.beta.sessions.update(
      session.id,
      agent={
          "tools": [
              {"type": "agent_toolset_20260401"},
              {"type": "mcp_toolset", "mcp_server_name": "linear"},
          ],
          "mcp_servers": [
              {"type": "url", "name": "linear", "url": "https://mcp.linear.app/sse"}
          ],
      },
  )
  ```

  ```typescript TypeScript
  await client.beta.sessions.update(session.id, {
    agent: {
      tools: [
        { type: "agent_toolset_20260401" },
        { type: "mcp_toolset", mcp_server_name: "linear" }
      ],
      mcp_servers: [{ type: "url", name: "linear", url: "https://mcp.linear.app/sse" }]
    }
  });
  ```

  ```csharp C#
  await client.Beta.Sessions.Update(session.ID, new()
  {
      Agent = new()
      {
          Tools =
          [
              new BetaManagedAgentsAgentToolset20260401Params
              {
                  Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
              },
              new BetaManagedAgentsMcpToolsetParams
              {
                  Type = BetaManagedAgentsMcpToolsetParamsType.McpToolset,
                  McpServerName = "linear",
              },
          ],
          McpServers =
          [
              new()
              {
                  Type = BetaManagedAgentsUrlMcpServerParamsType.Url,
                  Name = "linear",
                  Url = "https://mcp.linear.app/sse",
              },
          ],
      },
  });
  ```

  ```go Go
  _, err = client.Beta.Sessions.Update(ctx, session.ID, anthropic.BetaSessionUpdateParams{
  	Agent: anthropic.BetaManagedAgentsSessionAgentUpdateParam{
  		Tools: []anthropic.BetaManagedAgentsSessionAgentUpdateToolUnionParam{
  			{
  				OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  					Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  				},
  			},
  			{
  				OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
  					Type:          anthropic.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset,
  					MCPServerName: "linear",
  				},
  			},
  		},
  		MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{
  			{
  				Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL,
  				Name: "linear",
  				URL:  "https://mcp.linear.app/sse",
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().update(
      session.id(),
      SessionUpdateParams.builder()
          .agent(BetaManagedAgentsSessionAgentUpdate.builder()
              .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
                  .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
                  .build())
              .addTool(BetaManagedAgentsMcpToolsetParams.builder()
                  .type(BetaManagedAgentsMcpToolsetParams.Type.MCP_TOOLSET)
                  .mcpServerName("linear")
                  .build())
              .addMcpServer(BetaManagedAgentsUrlMcpServerParams.builder()
                  .type(BetaManagedAgentsUrlMcpServerParams.Type.URL)
                  .name("linear")
                  .url("https://mcp.linear.app/sse")
                  .build())
              .build())
          .build()
  );
  ```

  ```php PHP
  $client->beta->sessions->update(
      $session->id,
      agent: BetaManagedAgentsSessionAgentUpdate::with(
          tools: [
              BetaManagedAgentsAgentToolset20260401Params::with(type: 'agent_toolset_20260401'),
              BetaManagedAgentsMCPToolsetParams::with(mcpServerName: 'linear', type: 'mcp_toolset'),
          ],
          mcpServers: [
              BetaManagedAgentsURLMCPServerParams::with(
                  name: 'linear',
                  type: 'url',
                  url: 'https://mcp.linear.app/sse',
              ),
          ],
      ),
  );
  ```

  ```ruby Ruby
  client.beta.sessions.update(
    session.id,
    agent: {
      tools: [
        {type: :agent_toolset_20260401},
        {type: :mcp_toolset, mcp_server_name: "linear"}
      ],
      mcp_servers: [
        {type: :url, name: "linear", url: "https://mcp.linear.app/sse"}
      ]
    }
  )
  ```
</CodeGroup>

## Обновление бюджета сессии

Сессия, [созданная с бюджетом](https://platform.claude.com/docs/ru/managed-agents/sessions#set-a-session-budget), принимает два вида обновления бюджета: замену лимита новым значением `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) и его удаление путём передачи `"budget": null` (python: `budget=None`; typescript: `budget: null`; ruby: `budget: nil`; go: `Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam]()`; java: `.budget(Optional.empty())`; csharp: `Budget = null`; php: `requestOptions: ['extraBodyParams' => ['budget' => null]]`; cli: `--budget null`). Оба варианта автоматически возобновляют работу, приостановленную, когда сессия достигла своего лимита. Новый лимит может быть выше или ниже текущего, но он должен быть строго больше уже израсходованной сессией прейскурантной стоимости, а удаление необратимо: ненулевое значение `budget` (csharp, go: `Budget`) принимается только для сессии, у которой в данный момент есть бюджет, поэтому нельзя повторно добавить удалённый бюджет или добавить его сессии, созданной без бюджета. Примеры запросов, поведение при ошибках и то, что учитывается в прейскурантной стоимости, см. в разделе [Бюджеты сессий](https://platform.claude.com/docs/ru/managed-agents/budgets#resume-a-session-at-its-budget).

## Получение сессии

<CodeGroup>
  ```bash cURL
  curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  ant beta:sessions retrieve --session-id "$SESSION_ID"
  ```

  ```python Python
  retrieved = client.beta.sessions.retrieve(session.id)
  print(f"Status: {retrieved.status}")
  ```

  ```typescript TypeScript
  const retrieved = await client.beta.sessions.retrieve(session.id);
  console.log(`Status: ${retrieved.status}`);
  ```

  ```csharp C#
  var retrieved = await client.Beta.Sessions.Retrieve(session.ID);
  Console.WriteLine($"Status: {retrieved.Status.Raw()}");
  ```

  ```go Go
  retrieved, err := client.Beta.Sessions.Get(ctx, session.ID, anthropic.BetaSessionGetParams{})
  if err != nil {
  	panic(err)
  }
  fmt.Printf("Status: %s\n", retrieved.Status)
  ```

  ```java Java
  var retrieved = client.beta().sessions().retrieve(session.id());
  IO.println("Status: " + retrieved.status());
  ```

  ```php PHP
  $retrieved = $client->beta->sessions->retrieve($session->id);
  echo "Status: {$retrieved->status}\n";
  ```

  ```ruby Ruby
  retrieved = client.beta.sessions.retrieve(session.id)
  puts "Status: #{retrieved.status}"
  ```
</CodeGroup>

## Перечисление сессий

Результаты `GET /v1/sessions` разбиваются на страницы. Используйте параметр запроса `limit`, чтобы управлять размером страницы. Каждый ответ содержит курсор `next_page`; передайте его в качестве параметра `page` в следующем запросе, чтобы получить следующую страницу. `next_page` равен `null`, когда результатов больше нет.

Чтобы вернуться на страницу назад, передайте `prev_page` в качестве параметра `page`. `prev_page` равен `null`, когда вы находитесь на первой странице.

Курсор `page` непрозрачен и кодирует `order` запроса, который его создал. Параметр запроса `order` задаёт направление сортировки результатов — `asc` или `desc` по времени создания; по умолчанию используется `desc` (сначала самые новые). Повторное использование курсора с другим значением `order` возвращает ошибку 400, как и изменение фильтра `created_at` таким образом, что он исключает позицию курсора. Другие параметры запроса, включая остальные фильтры и `limit`, могут меняться между постраничными запросами. Поля пагинации, общие для всех эндпоинтов списков, описаны в разделе [Пагинация](https://platform.claude.com/docs/ru/api/overview#pagination).

<CodeGroup>
  ```bash cURL
  curl -sS --fail-with-body \
    "https://api.anthropic.com/v1/sessions?agent_id=$AGENT_ID&limit=1" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  # Передайте next_page обратно как параметр запроса page, чтобы получить следующую страницу,
  # или prev_page, чтобы вернуться назад.
  ```

  ```bash CLI
  # --format raw возвращает один конверт страницы с курсорами prev_page и next_page;
  # вывод по умолчанию автоматически перебирает страницы и выдаёт только сессии.
  ant beta:sessions list \
    --agent-id "$AGENT_ID" \
    --limit 1 \
    --format raw
  # Передайте next_page обратно как --page, чтобы получить следующую страницу, или prev_page, чтобы вернуться назад.
  ```

  ```python Python
  # Задаём небольшой `limit`, чтобы результаты заняли больше одной страницы.
  first_page = client.beta.sessions.list(limit=1, agent_id=agent.id)
  # `prev_page` равен None на первой странице; `next_page` равен None на последней.
  print(f"prev_page: {first_page.prev_page}")
  print(f"next_page: {first_page.next_page}")

  # Передайте `next_page` обратно как `page`, чтобы получить следующую страницу.
  second_page = client.beta.sessions.list(
      limit=1, agent_id=agent.id, page=first_page.next_page
  )
  for listed_session in second_page.data:
      print(f"{listed_session.id}: {listed_session.status}")

  # Передайте `prev_page` обратно как `page`, чтобы вернуться на предыдущую страницу.
  previous_page = client.beta.sessions.list(
      limit=1, agent_id=agent.id, page=second_page.prev_page
  )
  for listed_session in previous_page.data:
      print(f"{listed_session.id}: {listed_session.status}")
  # Для итерации только вперёд объект страницы также можно перебирать напрямую.
  ```

  ```typescript TypeScript
  const firstPage = await client.beta.sessions.list({ limit: 1, agent_id: agent.id });
  // prev_page равен null на первой странице; next_page задан, когда есть ещё сессии.
  console.log(`prev_page: ${firstPage.prev_page}`);
  console.log(`next_page: ${firstPage.next_page}`);

  // Передайте next_page как курсор `page`, чтобы получить вторую страницу.
  const secondPage = await client.beta.sessions.list({
    limit: 1,
    agent_id: agent.id,
    page: firstPage.next_page
  });
  for (const listedSession of secondPage.data) {
    console.log(`Page 2 has ${listedSession.id}: ${listedSession.status}`);
  }

  // Передайте курсор prev_page второй страницы, чтобы вернуться к первой.
  const previousPage = await client.beta.sessions.list({
    limit: 1,
    agent_id: agent.id,
    page: secondPage.prev_page
  });
  for (const listedSession of previousPage.data) {
    console.log(`Back on page 1: ${listedSession.id} is ${listedSession.status}`);
  }
  // Для итерации только вперёд объект страницы также можно перебирать напрямую.
  ```

  ```csharp C#
  // SessionListPage, возвращаемый `List`, предоставляет элементы, но не
  // курсоры пагинации. Чтобы прочитать `prev_page` / `next_page`, десериализуйте сырой
  // ответ в SessionListPageResponse.
  using var page1Response = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID }
  );
  var page1 = await page1Response.Deserialize<SessionListPageResponse>();
  Console.WriteLine($"prev_page: {page1.PrevPage ?? "null"}");
  Console.WriteLine($"next_page: {page1.NextPage ?? "null"}");

  // Вперёд: передаём `next_page` со страницы 1 как курсор `page`.
  using var page2Response = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID, Page = page1.NextPage }
  );
  var page2 = await page2Response.Deserialize<SessionListPageResponse>();
  foreach (var listedSession in page2.Data ?? [])
  {
      Console.WriteLine($"Page 2: {listedSession.ID}: {listedSession.Status.Raw()}");
  }

  // Назад: передаём `prev_page` со страницы 2 как тот же курсор `page`.
  using var previousPageResponse = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID, Page = page2.PrevPage }
  );
  var previousPage = await previousPageResponse.Deserialize<SessionListPageResponse>();
  foreach (var listedSession in previousPage.Data ?? [])
  {
      Console.WriteLine($"Back to page 1: {listedSession.ID}: {listedSession.Status.Raw()}");
  }
  // Для итерации только вперёд (await client.Beta.Sessions.List(...)).Paginate() возвращает IAsyncEnumerable, который автоматически следует по next_page.
  ```

  ```go Go
  // Страница 1: prev_page пуст, так как перед первой страницей ничего нет.
  firstPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  })
  if err != nil {
  	panic(err)
  }
  fmt.Printf("Page 1 prev_page: %q\n", firstPage.PrevPage)
  fmt.Printf("Page 1 next_page: %q\n", firstPage.NextPage)

  // Вперёд: передаём next_page как курсор Page, чтобы получить страницу 2.
  secondPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  	Page:    anthropic.String(firstPage.NextPage),
  })
  if err != nil {
  	panic(err)
  }
  for _, listedSession := range secondPage.Data {
  	fmt.Printf("Page 2: %s: %s\n", listedSession.ID, listedSession.Status)
  }

  // Назад: prev_page страницы 2 — это курсор предыдущей страницы.
  previousPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  	Page:    anthropic.String(secondPage.PrevPage),
  })
  if err != nil {
  	panic(err)
  }
  for _, listedSession := range previousPage.Data {
  	fmt.Printf("Back to page 1: %s: %s\n", listedSession.ID, listedSession.Status)
  }
  // Для итерации только вперёд используйте ListAutoPaging: он сам следует по next_page.
  ```

  ```java Java
  var params = SessionListParams.builder()
      .agentId(agent.id())
      .limit(1)
      .build();
  var firstPage = client.beta().sessions().list(params);
  for (var listedSession : firstPage.data()) {
      IO.println(listedSession.id() + ": " + listedSession.status());
  }
  // prev_page — пустой Optional на первой странице; next_page указывает на страницу 2.
  IO.println("prev_page: " + firstPage.response().prevPage());
  IO.println("next_page: " + firstPage.response().nextPage());

  // Переходим вперёд, передавая next_page как курсор страницы.
  var nextCursor = firstPage.response().nextPage().orElseThrow();
  var secondPage = client.beta().sessions().list(params.toBuilder().page(nextCursor).build());

  // Возвращаемся назад, передавая prev_page как тот же курсор страницы.
  var prevCursor = secondPage.response().prevPage().orElseThrow();
  var previousPage = client.beta().sessions().list(params.toBuilder().page(prevCursor).build());
  // Снова на первой странице, поэтому prev_page опять пуст.
  IO.println("prev_page: " + previousPage.response().prevPage());
  // Для итерации только вперёд page.autoPager() возвращает Iterable, автоматически следующий по next_page.
  ```

  ```php PHP
  // Страница 1: prevPage равен null, потому что перед первой страницей ничего нет.
  $firstPage = $client->beta->sessions->list(agentID: $agent->id, limit: 1);
  echo 'Page 1 prev_page: ' . ($firstPage->prevPage ?? 'null') . "\n";
  echo 'Page 1 next_page: ' . ($firstPage->nextPage ?? 'null') . "\n";

  // Вперёд: передаём nextPage как курсор `page`, чтобы получить страницу 2.
  $secondPage = $client->beta->sessions->list(
      agentID: $agent->id,
      limit: 1,
      page: $firstPage->nextPage,
  );
  foreach ($secondPage->getItems() as $listedSession) {
      echo "Page 2: {$listedSession->id}: {$listedSession->status}\n";
  }

  // Назад: prevPage страницы 2 — это курсор предыдущей страницы.
  $previousPage = $client->beta->sessions->list(
      agentID: $agent->id,
      limit: 1,
      page: $secondPage->prevPage,
  );
  foreach ($previousPage->getItems() as $listedSession) {
      echo "Back to page 1: {$listedSession->id}: {$listedSession->status}\n";
  }
  // Для итерации только вперёд $page->pagingEachItem() выдаёт все сессии со всех страниц.
  ```

  ```ruby Ruby
  first_page = client.beta.sessions.list(agent_id: agent.id, limit: 1)
  first_page.data.each do |listed_session|
    puts "#{listed_session.id}: #{listed_session.status}"
  end

  # `prev_page` равен nil на первой странице. Курсор следующей страницы доступен как
  # `next_page_` (с подчёркиванием в конце), потому что просто `next_page` — это вспомогательный
  # метод, который сам получает объект следующей страницы.
  puts "prev_page: #{first_page.prev_page.inspect}"
  puts "next_page: #{first_page.next_page_.inspect}"

  # Передайте любой из курсоров обратно как `page`, чтобы перемещаться по списку в обоих направлениях.
  second_page = client.beta.sessions.list(
    agent_id: agent.id,
    limit: 1,
    page: first_page.next_page_
  )
  back_to_first = client.beta.sessions.list(
    agent_id: agent.id,
    limit: 1,
    page: second_page.prev_page
  )
  back_to_first.data.each do |listed_session|
    puts "#{listed_session.id}: #{listed_session.status}"
  end
  # Для итерации только вперёд page.auto_paging_each автоматически следует по next_page.
  ```
</CodeGroup>

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

Архивируйте сессию, чтобы запретить отправку новых событий, сохранив при этом её историю. Сессию в статусе `running` нельзя архивировать; чтобы архивировать её, отправьте отдельно [событие `user.interrupt`](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#interrupt-the-agent) и дождитесь, пока сессия перейдёт в статус `idle`. Если открыт [запуск рабочего процесса](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#while-a-run-is-open), архивирование может вернуть ошибку 400, даже если сессия находится в статусе `idle`, либо может завершиться успешно и завершить запуск. Перед архивированием отправьте `user.message`, в котором [попросите агента остановить его запуски](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), или дождитесь завершения каждого запуска. Затем архивируйте сессию, когда она перейдёт в статус `idle`.

<CodeGroup>
  ```bash cURL
  curl -fsSL -X POST "https://api.anthropic.com/v1/sessions/$SESSION_ID/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  ant beta:sessions archive \
    --session-id "$SESSION_ID"
  ```

  ```python Python
  client.beta.sessions.archive(session.id)
  ```

  ```typescript TypeScript
  await client.beta.sessions.archive(session.id);
  ```

  ```csharp C#
  await client.Beta.Sessions.Archive(session.ID);
  ```

  ```go Go
  _, err = client.Beta.Sessions.Archive(ctx, session.ID, anthropic.BetaSessionArchiveParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().archive(session.id());
  ```

  ```php PHP
  $client->beta->sessions->archive($session->id);
  ```

  ```ruby Ruby
  client.beta.sessions.archive(session.id)
  ```
</CodeGroup>

## Удаление сессии

Удалите сессию, чтобы безвозвратно удалить её запись, события и связанную с ней песочницу. Сессию в статусе `running` нельзя удалить; чтобы удалить её, отправьте отдельно [событие `user.interrupt`](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming#interrupt-the-agent) и дождитесь, пока сессия перейдёт в статус `idle`. Если открыт [запуск рабочего процесса](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#while-a-run-is-open), удаление может вернуть ошибку 400, даже если сессия находится в статусе `idle`, либо может завершиться успешно. После успешного удаления никакое событие `workflow_run` не сообщает о завершении запусков сессии. Перед удалением отправьте `user.message`, в котором [попросите агента остановить его запуски](https://platform.claude.com/docs/ru/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), или дождитесь завершения каждого запуска. Затем удалите сессию, когда она перейдёт в статус `idle`.

Хранилища памяти, хранилища секретов (vaults), навыки, окружения и агенты являются независимыми ресурсами и не затрагиваются удалением сессии. Файлы, загруженные вами через Files API, также не затрагиваются, однако файлы, созданные самой сессией, привязаны к ней и безвозвратно удаляются вместе с её файловой системой. Скачайте всё, что вам нужно сохранить, перед удалением сессии. Выходной файл, записанный в конце последнего хода, может появиться в [списке файлов сессии](https://platform.claude.com/docs/ru/managed-agents/files#listing-and-downloading-session-files) лишь через несколько секунд после перехода сессии в статус idle, поэтому сначала убедитесь, что ожидаемые файлы присутствуют в списке.

<CodeGroup>
  ```bash cURL
  curl -fsSL -X DELETE "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  ant beta:sessions delete \
    --session-id "$SESSION_ID"
  ```

  ```python Python
  client.beta.sessions.delete(session.id)
  ```

  ```typescript TypeScript
  await client.beta.sessions.delete(session.id);
  ```

  ```csharp C#
  await client.Beta.Sessions.Delete(session.ID);
  ```

  ```go Go
  _, err = client.Beta.Sessions.Delete(ctx, session.ID, anthropic.BetaSessionDeleteParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().delete(session.id());
  ```

  ```php PHP
  $client->beta->sessions->delete($session->id);
  ```

  ```ruby Ruby
  client.beta.sessions.delete(session.id)
  ```
</CodeGroup>