---
title: セッション操作
url: https://platform.claude.com/docs/ja/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/ja/managed-agents/sessions)を参照してください。

## セッションのステータス

セッションは以下のステータスを経て進行します。セッションのライフサイクルについては、[セッションを開始する](https://platform.claude.com/docs/ja/managed-agents/sessions)を参照してください。

| ステータス          | 説明                                                                                                                                                                                                                                                                                                                                                                                                                              |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `idle`         | エージェントがユーザーメッセージやツールの確認などの入力を待機しています。`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)なしで作成されたセッションは`idle`から開始します。[ワークフロー実行](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#while-a-run-is-open)がまだ開いている間もセッションが`idle`になることがあるため、`idle`だけでは作業が完了したことを意味しません。[作業が完了したタイミングを知る](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#know-when-the-work-is-done)を参照してください。 |
| `running`      | エージェントがアクティブに実行中です。                                                                                                                                                                                                                                                                                                                                                                                                             |
| `rescheduling` | 一時的なエラーが発生し、自動的に再試行しています。                                                                                                                                                                                                                                                                                                                                                                                                       |
| `terminated`   | 回復不能なエラーが発生したか、アーカイブされたために、セッションが終了しました。作業を完了したセッションは`terminated`ではなく`idle`になります。                                                                                                                                                                                                                                                                                                                                               |

## エージェント設定の更新

新しいエージェントバージョンを作成することなく、セッションの途中でセッションの`agent.tools` (csharp, go: `Agent.Tools`)と`agent.mcp_servers` (java, php: `agent.mcpServers`; csharp: `Agent.McpServers`; go: `Agent.MCPServers`)を更新できます。これには、権限ポリシーや、[ドメインフィルター](https://platform.claude.com/docs/ja/managed-agents/tools-web-restrictions#change-the-lists-mid-session)などのツールごとのWeb設定も含まれます。更新はセッションローカルであり、基になるエージェントには反映されません。更新された`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/ja/managed-agents/sessions#override-agent-configuration-for-a-session)を使用してください。エージェントのモデル設定（[`inference_geo`](https://platform.claude.com/docs/ja/manage-claude/data-residency)の固定を含む）もセッションの途中で変更することはできません。固定はエージェントの保存時に設定するか、セッションの作成時に`model` (csharp, go: `Model`)オーバーライドを使用して単一のセッションに対して設定またはクリアしてください。エージェントに設定された`system` (csharp, go: `System`; ruby: `system_`)フィールドは、セッションの存続期間中は固定されます。対応しているモデルでは、[`system.message`イベント](https://platform.claude.com/docs/ja/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/ja/managed-agents/events-and-streaming#interrupt-the-agent)を単独で送信し、セッションが`idle`になるまで待ちます。[ワークフロー実行](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#while-a-run-is-open)が開いている場合、それが実行中か一時停止中かにかかわらず、セッションが`idle`であっても更新は400エラーを返します。中断しても実行は終了しないため、セッションを中断した後も更新は失敗します。[エージェントに実行の停止を依頼する](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#interrupt-a-session-with-runs-open)`user.message`を送信するか、すべての実行が終了するまで待ってください。

<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/ja/managed-agents/sessions#set-a-session-budget)セッションは、2種類の予算更新を受け付けます。新しい`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`)を渡して上限を削除する更新です。どちらも、セッションが上限に達したために一時停止していた作業を自動的に再開します。置き換える上限は現在の上限より高くても低くてもかまいませんが、セッションで消費済みのリストコストより厳密に大きくなければなりません。また、削除は一方向です。null以外の`budget` (csharp, go: `Budget`)は現在予算を持つセッションでのみ受け付けられるため、削除した予算を再度追加したり、予算なしで作成されたセッションに予算を追加したりすることはできません。リクエストの例、エラー時の動作、リストコストに計上される内容については、[セッション予算](https://platform.claude.com/docs/ja/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/ja/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"
  # Pass next_page back as the page query parameter to fetch the next page,
  # or prev_page to go back.
  ```

  ```bash CLI
  # --format raw returns one page envelope with its prev_page and next_page
  # cursors; the default output auto-paginates and emits only the sessions.
  ant beta:sessions list \
    --agent-id "$AGENT_ID" \
    --limit 1 \
    --format raw
  # Pass next_page back as --page to fetch the next page, or prev_page to go back.
  ```

  ```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` カーソルとして渡し、2ページ目を取得します。
  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}`);
  }

  // 2ページ目の prev_page カーソルを渡して、1ページ目に戻ります。
  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#
  // `List` が返す SessionListPage はアイテムを公開しますが、ページネーション
  // カーソルは公開しません。`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"}");

  // 次へ進む: ページ1の `next_page` を `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()}");
  }

  // 戻る: ページ2の `prev_page` を同じ `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() が next_page を自動的に辿る IAsyncEnumerable を返します。
  ```

  ```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)
  }

  // 戻る: ページ2の prev_page は、その前のページのカーソルです。
  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)
  }
  // 前方のみの反復には、next_page を自動で辿る ListAutoPaging を使用します。
  ```

  ```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() が next_page を自動的にたどる Iterable を返します。
  ```

  ```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";
  }

  // 後退: ページ 2 の prevPage は、その前のページのカーソルです。
  $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/ja/managed-agents/events-and-streaming#interrupt-the-agent)を単独で送信し、セッションが`idle`になるまで待ちます。[ワークフロー実行](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#while-a-run-is-open)が開いている場合、セッションが`idle`であってもアーカイブが400エラーを返すことがあり、あるいはアーカイブが成功して実行が終了することもあります。アーカイブする前に、[エージェントに実行の停止を依頼する](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#interrupt-a-session-with-runs-open)`user.message`を送信するか、各実行が終了するまで待ってください。その後、セッションが`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/ja/managed-agents/events-and-streaming#interrupt-the-agent)を単独で送信し、セッションが`idle`になるまで待ちます。[ワークフロー実行](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#while-a-run-is-open)が開いている場合、セッションが`idle`であっても削除が400エラーを返すことがあり、あるいは削除が成功することもあります。削除が成功した後は、セッションの実行の終了を報告する`workflow_run`イベントはありません。削除する前に、[エージェントに実行の停止を依頼する](https://platform.claude.com/docs/ja/managed-agents/workflow-runs#interrupt-a-session-with-runs-open)`user.message`を送信するか、各実行が終了するまで待ってください。その後、セッションが`idle`になったら削除します。

メモリストア、ボールト、スキル、環境、およびエージェントは独立したリソースであり、セッションの削除による影響を受けません。Files APIを通じてアップロードしたファイルも影響を受けませんが、セッション自体が生成したファイルはそのセッションにスコープされており、ファイルシステムとともに永久に削除されます。セッションを削除する前に、保持する必要があるものはすべてダウンロードしてください。最後のターンの終わりに書き込まれた出力ファイルは、セッションがidleになってから[セッションのファイル一覧](https://platform.claude.com/docs/ja/managed-agents/files#listing-and-downloading-session-files)に表示されるまで数秒かかることがあるため、まず期待するファイルが一覧に表示されていることを確認してください。

<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>
