---
title: 夢境（Dreams）
url: https://platform.claude.com/docs/zh-TW/managed-agents/dreams
description: 讓 Claude 回顧過去的工作階段，以整理代理的記憶並發掘新的洞見。
---

<Tip>
  Dreaming（夢境）是一項研究預覽功能。[申請存取權限](https://claude.com/form/claude-managed-agents)以試用。
</Tip>

代理在工作時會寫入其 [memory stores（記憶儲存庫）](https://platform.claude.com/docs/zh-TW/managed-agents/memory)，但這些寫入是局部且漸進的：經過許多工作階段後，記憶儲存庫會累積重複、矛盾與過時的條目。

**Dreams**（夢境）讓 Claude 清理這些內容。一次夢境會讀取現有的記憶儲存庫以及過去的工作階段逐字稿，然後產生一個全新、重新組織過的記憶儲存庫：重複項目被合併、過時或相互矛盾的條目被替換為最新的值，並發掘出新的洞見。

輸入儲存庫永遠不會被修改，因此您可以檢視輸出結果，若不滿意即可將其捨棄。

<Note>
  夢境端點受 `dreaming-2026-04-21` beta 標頭管控；單獨使用 `managed-agents-2026-04-01` 標頭並不會授予夢境的存取權限。本頁的夢境端點範例會同時傳送這兩個標頭；工作階段與記憶儲存庫的呼叫只需要 `managed-agents-2026-04-01`。SDK 會自動設定這些標頭。
</Note>

## 運作方式

一個 **dream**（夢境）是一項非同步作業，其輸入包含：

* 一個既有的 **memory store（記憶儲存庫）：** Claude 會驗證、去除重複並重新組織的儲存庫，以及
* 1 到 100 個 **sessions（工作階段）：** Claude 從中挖掘模式與洞見、並將其整合進輸出的過去逐字稿。

夢境會產生另一個 **output memory store（輸出記憶儲存庫）**，與輸入分開。在夢境開始 `running` 後不久、工作流程複製完輸入儲存庫時，輸出儲存庫 ID 就會出現在夢境的 `outputs` (csharp, go: `Outputs`) 陣列中；處於 `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/zh-TW/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/zh-TW/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/zh-TW/managed-agents/memory#view-and-edit-memories)。

## 追蹤進度

夢境以非同步方式執行，通常需要數分鐘到數小時，取決於輸入逐字稿的數量。透過 ID 輪詢夢境以檢查狀態：

<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/zh-TW/managed-agents/sessions)。您可以串流該工作階段的[事件](https://platform.claude.com/docs/zh-TW/managed-agents/events-and-streaming)，即時觀察夢境正在讀取和寫入的內容。當夢境達到終止狀態時，該工作階段會被封存（而非刪除），因此之後仍可取得其逐字稿。

## 使用輸出

當 `status` (csharp, go: `Status`) 達到 `completed` 時，`outputs` (csharp, go: `Outputs`) 中的 `memory_store` 項目會參照一個已完整填入內容的儲存庫。它是您工作區中的一般記憶儲存庫。請使用 [Memory Stores API](https://platform.claude.com/docs/zh-TW/managed-agents/memory#view-and-edit-memories) 或在 Console 中檢閱它，然後選擇：

* **加以運用：** 將其作為 `memory_store` 資源附加到未來的工作階段，以取代（或搭配）輸入記憶儲存庫，或
* **將其捨棄：** [刪除該記憶儲存庫](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/delete)或[封存該記憶儲存庫](https://platform.claude.com/docs/zh-TW/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>

## 封存夢境

封存會在已達終止狀態（`completed`、`failed` 或 `canceled`）的夢境上設定 `archived_at` (java, php: `archivedAt`; csharp, go: `ArchivedAt`)；`status` (csharp, go: `Status`) 保持不變。已封存的夢境會從預設的列表回應中排除，但仍可依 ID 讀取。封存已封存的夢境是冪等的無操作。封存 `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/zh-TW/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 token 費率計費；資源上的 `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)。