> ## Documentation Index
> Fetch the complete documentation index at: https://docs.qoder.com/llms.txt
> Use this file to discover all available pages before exploring further.

# SDK References

<div id="functions" />

## Functions

<div id="query" />

### `query()`

SDK のメインエントリ関数です。到着順にメッセージをストリーミングする非同期イテレータを作成します。

```python theme={null}
async def query(
    *,
    prompt: str | AsyncIterable[dict[str, Any]],
    options: QoderAgentOptions | None = None,
) -> AsyncIterator[Message]:
    ...
```

<div id="parameters" />

#### Parameters

| パラメータ     | 型                                         | 説明                                      |
| :-------- | :---------------------------------------- | :-------------------------------------- |
| `prompt`  | `str \| AsyncIterable[dict[str, Any]]`    | 単一ターンの場合は文字列を渡し、マルチターンの場合は非同期イテラブルを渡します |
| `options` | [`QoderAgentOptions`](#qoderagentoptions) | 任意のセッション構成                              |

<div id="return-value" />

<div id="returnvalue" />

#### Return Value

`AsyncIterator[Message]` を返し、`async for` で消費します。

<div id="qodersdkclient" />

### `QoderSDKClient`

クラスベースのマルチターン会話 API です。ターンをまたいでセッション状態を保持したり、モデルやパーミッションモードを動的に切り替えたりするシナリオに適しています。

```python theme={null}
client = QoderSDKClient(options=options)
await client.connect("Initial prompt.")
```

| メソッド                                             | 説明                                      |
| :----------------------------------------------- | :-------------------------------------- |
| `client.query(prompt)`                           | 新しいターンのユーザー入力を送信                        |
| `client.receive_response()`                      | `ResultMessage` までメッセージを消費              |
| `client.receive_messages()`                      | セッション全体のメッセージストリームを受信するバックグラウンド非同期イテレータ |
| `client.connect(prompt)` / `client.disconnect()` | 接続を手動で管理                                |
| `client.interrupt()`                             | 現在の生成またはツール実行を中断                        |
| `client.set_model(model)`                        | 実行時にモデルを切り替え                            |
| `client.set_permission_mode(mode)`               | 実行時にパーミッションモードを切り替え                     |
| `client.stop_task(task_id)`                      | バックグラウンドタスクを停止                          |
| `client.apply_flag_settings(settings)`           | フラグレベルの設定を注入                            |
| `client.supported_agents()`                      | 現在利用可能なエージェントを一覧表示                      |
| `client.get_mcp_status()`                        | すべての MCP サーバーのステータスを取得                  |
| `client.set_mcp_servers(servers)`                | MCP サーバー構成を置き換え                         |
| `client.reconnect_mcp_server(name)`              | 特定の MCP サーバーを再接続                        |
| `client.toggle_mcp_server(name, enabled)`        | MCP サーバーの有効/無効を切り替え                     |
| `client.get_available_models()`                  | 利用可能なモデル一覧を取得                           |

<div id="types" />

## Types

<div id="qoderagentoptions" />

### `QoderAgentOptions`

`query()` および `QoderSDKClient` の構成オブジェクトです。Python SDK では snake\_case のフィールド名を使用します。

| フィールド                                | 型                                                       | デフォルト   | 説明                                                                                      |
| :----------------------------------- | :------------------------------------------------------ | :------ | :-------------------------------------------------------------------------------------- |
| `auth`                               | `InternalAuthOptions \| dict \| None`                   | `None`  | 認証構成                                                                                    |
| `on_auth_expired`                    | `Callable \| None`                                      | `None`  | 認証期限切れ時のコールバック。セッションごとに最大 1 回トリガーされます                                                   |
| `tools`                              | `list[str] \| ToolsPreset \| None`                      | `None`  | ツールセット。文字列配列を渡すと利用可能なツールを制限します。組み込みツール名は [組み込みツール一覧](#built-in-tool-list) を参照           |
| `allowed_tools`                      | `list[str]`                                             | `[]`    | ツール許可リスト。記載されたツールは事前に承認されます                                                             |
| `disallowed_tools`                   | `list[str]`                                             | `[]`    | ツール拒否リスト。`allowed_tools` と `permission_mode` より優先されます                                   |
| `can_use_tool`                       | [`CanUseTool`](#canusetool)                             | `None`  | カスタムツールパーミッションコールバック                                                                    |
| `permission_mode`                    | [`PermissionMode`](#permissionmode)                     | `None`  | セッションパーミッションモード                                                                         |
| `allow_dangerously_skip_permissions` | `bool`                                                  | `False` | パーミッションチェックのスキップを許可。`permission_mode="bypassPermissions"` と併用                           |
| `permission_prompt_tool_name`        | `str \| None`                                           | `None`  | パーミッションプロンプト用の MCP ツール名。`can_use_tool` と相互排他                                            |
| `model`                              | `str \| None`                                           | `None`  | 使用するモデル                                                                                 |
| `fallback_model`                     | `str \| None`                                           | `None`  | メインモデル失敗時のフォールバックモデル                                                                    |
| `resolve_model`                      | [`ModelPolicyProvider`](#modelpolicyprovider)           | `None`  | 動的モデル選択コールバック。渡すと動的コールバックモードに切り替わります。詳細は [モデルポリシー](/ja/cli/sdk/python/model-policy) を参照 |
| `resolve_model_timeout_ms`           | `int`                                                   | `500`   | コールバックタイムアウト（ミリ秒）。`resolve_model` を渡した場合のみ有効                                            |
| `system_prompt`                      | `str \| SystemPromptPreset \| SystemPromptFile \| None` | `None`  | システムプロンプト                                                                               |
| `cwd`                                | `str \| Path \| None`                                   | `None`  | 作業ディレクトリ                                                                                |
| `env`                                | `dict[str, str \| None]`                                | `{}`    | CLI プロセスに渡す環境変数                                                                         |
| `cli_path`                           | `str \| Path \| None`                                   | `None`  | qodercli 実行ファイルへのパス                                                                     |
| `session_id`                         | `str \| None`                                           | `None`  | セッション UUID を指定                                                                          |
| `resume`                             | `str \| None`                                           | `None`  | 再開するセッション ID                                                                            |
| `continue_conversation`              | `bool`                                                  | `False` | 直近のセッションを継続                                                                             |
| `fork_session`                       | `bool`                                                  | `False` | `resume` と併用すると、新しいセッション ID にフォーク                                                       |
| `max_turns`                          | `int \| None`                                           | `None`  | 最大会話ターン数                                                                                |
| `include_partial_messages`           | `bool`                                                  | `False` | `StreamEvent` ストリーミング断片を含める。詳細は [ストリーミング出力](/ja/cli/sdk/python/streaming-output) を参照    |
| `mcp_servers`                        | `dict[str, McpServerConfig] \| str \| Path`             | `{}`    | MCP サーバー構成。詳細は [MCP](/ja/cli/sdk/python/mcp) を参照                                        |
| `allowed_mcp_server_names`           | `list[str]`                                             | `[]`    | 利用可能な MCP サーバーを制限                                                                       |
| `strict_mcp_config`                  | `bool`                                                  | `False` | 厳密な MCP 検証                                                                              |
| `hooks`                              | `dict[HookEvent, list[HookMatcher]] \| None`            | `None`  | ライフサイクルフック。詳細は [Hooks](/ja/cli/sdk/python/hooks) を参照                                    |
| `agents`                             | `dict[str, AgentDefinition] \| None`                    | `None`  | プログラム的に定義されたサブエージェント。詳細は [Agents リファレンス](#qoderagentoptionsagents) を参照                  |
| `agent`                              | `str \| None`                                           | `None`  | メインスレッドが使用するエージェント名。詳細は [Agents リファレンス](#qoderagentoptionsagent) を参照                    |
| `settings`                           | `str \| Path \| Settings \| None`                       | `None`  | インライン設定オブジェクトまたは設定ファイルパス                                                                |
| `setting_sources`                    | `list[SettingSource] \| None`                           | `None`  | 読み込むファイルシステム設定                                                                          |
| `add_dirs`                           | `list[str \| Path]`                                     | `[]`    | AI がアクセス可能な追加ディレクトリ                                                                     |
| `extra_args`                         | `dict[str, str \| None]`                                | `{}`    | CLI に渡す追加引数                                                                             |
| `plugins`                            | `list[SdkPluginConfig]`                                 | `[]`    | ローカルプラグインを読み込む。詳細は [Plugins](/ja/cli/sdk/python/plugins) を参照                            |
| `skills`                             | `list[str] \| Literal["all"] \| None`                   | `None`  | 有効化するスキル。`"all"` を渡すとすべて有効化                                                             |
| `enable_file_checkpointing`          | `bool \| None`                                          | `None`  | ファイルチェックポイントを有効化                                                                        |
| `thinking`                           | `ThinkingConfig \| None`                                | `None`  | Thinking 構成                                                                             |

<div id="authentication" />

### Authentication

```python theme={null}
from qoder_agent_sdk import access_token, access_token_from_env, qodercli_auth
```

| ファクトリ関数                           | 説明                                              |
| :-------------------------------- | :---------------------------------------------- |
| `access_token(token)`             | PAT を直接渡す                                       |
| `access_token_from_env()`         | デフォルトの環境変数 `QODER_PERSONAL_ACCESS_TOKEN` から読み取る |
| `access_token_from_env("MY_PAT")` | 指定した環境変数から読み取る                                  |
| `qodercli_auth()`                 | ローカルの `qodercli login` セッションを再利用                |

便利な使い方については、[SDK 認証](/ja/cli/sdk/python/authentication) を参照してください。

<div id="agents-reference" />

<div id="agentsreference" />

## Agents Reference

このページでは、SDK Agents に関する安定した設定項目をまとめます。入門と利用シーンについては [サブエージェント利用ガイド](/ja/cli/sdk/python/agents) を参照してください。

<div id="sources-of-available-agents" />

<div id="sourcesofavailableagents" />

### Sources of Available Agents

現在のセッションで利用可能な Agent は、複数のソースから提供される場合があります：

| ソース             | 説明                                         |
| --------------- | ------------------------------------------ |
| SDK 登録          | `QoderAgentOptions.agents` を介して現在のセッションに登録 |
| CLI 組み込み        | qodercli 起動時に登録される組み込み Agent               |
| ユーザー / プロジェクト設定 | ユーザーまたはプロジェクトの設定ディレクトリ内の Agent 定義          |
| プラグイン           | ロード済みプラグインが提供する Agent                      |

対話型 CLI では `/agents` を実行して現在検出されている Agent を確認できます。コマンドラインでは `qodercli agents list` を実行します。Python SDK では `QoderSDKClient` の接続後、`client.supported_agents()` を呼び出して現在のセッションで利用可能な Agent のサマリを取得できます。

<div id="qoderagentoptionsagents" />

<div id="qoderagentoptions-agents" />

### `QoderAgentOptions.agents`

**型:** `dict[str, AgentDefinition] | None`

現在のセッションで利用可能なカスタム Agent を登録します。dict のキーは Agent 名、値はその Agent の定義です。

> **`Agent` ツールが必要**: カスタムサブエージェントは、メインセッションが組み込みの `Agent` ツールを介して委譲する必要があるため、`allowed_tools` に `Agent` ツールを含める必要があります。

```python theme={null}
from qoder_agent_sdk import AgentDefinition, QoderAgentOptions


options = QoderAgentOptions(
    allowed_tools=["Agent"],
    agents={
        "reviewer": AgentDefinition(
            description="Reviews code quality and reports actionable findings.",
            prompt="Review the requested code and report concrete issues.",
            tools=["Read", "Grep", "Glob"],
        ),
    },
)
```

登録後、モデルは組み込みの `Agent` ツールを介してこれらのサブエージェントを呼び出せます。メインセッションは作業を委譲するため、ツールセットに `Agent` を含める必要があります。`allowed_tools=["Agent"]` は必須の事前認可形式です。`tools` でメインセッションの利用可能ツールを絞り込む場合も、そこに `Agent` を含めてください。

<div id="qoderagentoptionsagent" />

<div id="qoderagentoptions-agent" />

### `QoderAgentOptions.agent`

**型:** `str | None`

メインセッションがどの Agent のアイデンティティとして実行されるかを指定します。値は `agents` に登録された名前、または現在の CLI が検出した組み込み / プラグイン Agent 名です。

```python theme={null}
options = QoderAgentOptions(
    agents={
        "planner": AgentDefinition(
            description="Plans work before implementation.",
            prompt="Break work into steps, risks, and validation checks.",
            tools=["Read", "Grep", "Glob"],
        ),
    },
    agent="planner",
)
```

設定すると、メインセッションはその Agent の `prompt`、`model`、ツール制限を使用します。省略した場合は、デフォルトのメインセッション動作が使用されます。

<div id="agentdefinition" />

### `AgentDefinition`

カスタム Agent の定義です。Python SDK の `AgentDefinition` は dataclass で、フィールド名はプロトコルスタイルの camelCase を使用します。以下のフィールドは、SDK で現在カバーされ、検証済みの安定した機能です。

```python theme={null}
from dataclasses import dataclass
from typing import Any, Literal


@dataclass
class AgentDefinition:
    description: str
    prompt: str
    tools: list[str] | None = None
    disallowedTools: list[str] | None = None
    model: str | None = None
    skills: list[str] | None = None
    mcpServers: list[str | dict[str, Any]] | None = None
    initialPrompt: str | None = None
    maxTurns: int | None = None
    effort: Literal["low", "medium", "high", "max"] | None = None
    permissionMode: PermissionMode | None = None
```

| フィールド             | 型                                              | 必須  | 説明                                                 |
| ----------------- | ---------------------------------------------- | --- | -------------------------------------------------- |
| `description`     | `str`                                          | はい  | Agent の用途説明。モデルはこれを使って Agent を呼び出すかどうかを判断          |
| `prompt`          | `str`                                          | はい  | Agent のシステムプロンプト                                   |
| `tools`           | `list[str] \| None`                            | いいえ | この Agent のツール許可リスト                                 |
| `disallowedTools` | `list[str] \| None`                            | いいえ | この Agent のツールセットから除外するツール                          |
| `model`           | `str \| None`                                  | いいえ | モデルのオーバーライド。`"inherit"` はメインセッションのモデルを継承           |
| `mcpServers`      | `list[str \| dict[str, Any]] \| None`          | いいえ | この Agent が利用可能な MCP サーバー指定                         |
| `skills`          | `list[str] \| None`                            | いいえ | Agent コンテキストにプリロードするスキル名                           |
| `initialPrompt`   | `str \| None`                                  | いいえ | この Agent をメインセッション Agent として使用する際に自動送信される最初のユーザー入力 |
| `maxTurns`        | `int \| None`                                  | いいえ | Agent の最大 API ターン数                                 |
| `effort`          | `"low" \| "medium" \| "high" \| "max" \| None` | いいえ | 推論の effort レベル                                     |
| `permissionMode`  | `PermissionMode \| None`                       | いいえ | この Agent 内のツール実行に対する権限モード                          |

Python SDK は `dataclasses.asdict()` を使って `AgentDefinition` を initialize リクエストにシリアライズし、qodercli は現在の Agent スキーマに従ってパースします。

<div id="description" />

#### `description`

Agent がどんなタスクに適しているかを記述します。モデルがこの Agent を選択するかどうかに影響します。

```python theme={null}
description="Runs project tests, analyzes failing output, and suggests fixes."
```

明確なトリガーシナリオを記述してください。`Helpful assistant` のような広範な記述は避けてください。

<div id="prompt" />

#### `prompt`

Agent のシステムプロンプト。役割、制約、出力形式を定義するために使用します。

```python theme={null}
prompt="""You are a security reviewer.
Check for authentication bypass, authorization bugs, injection risks, and secret leaks.
Return findings sorted by severity."""
```

<div id="tools" />

#### `tools`

Agent のツール許可リスト。設定すると、Agent はリストされたツールのみ使用可能です。

```python theme={null}
tools=["Read", "Grep", "Glob"]
```

`tools` を省略すると、サブエージェントのデフォルトツールセットが使用されます。サブエージェントのツールセットは、メインセッションの `allowed_tools` の絞り込みを継承しません。

<div id="disallowedtools" />

#### `disallowedTools`

Agent のツールセットから特定のツールを除外します。

```python theme={null}
disallowedTools=["Bash", "Write"]
```

`disallowedTools` を省略すると、サブエージェントはメインセッションの `disallowed_tools` の絞り込みを継承しません。最終的なツールセットを明示的に把握している場合を除き、通常は `tools` と `disallowedTools` を併用しないでください。

<div id="model" />

<div id="agentdefinition-model" />

#### `model`

Agent のモデルを指定します。省略するとセッションのデフォルトモデルが使用されます。Python の型レベルでは `str | None` で、SDK はローカルで特定の文字列を制限しません。一般的なモデル階層は以下のとおりです：

| 値               | 階層         | 説明                                | 適用                          | クレジットコスト |
| --------------- | ---------- | --------------------------------- | --------------------------- | -------- |
| `"auto"`        | スマートルーティング | 能力とコストのバランスを取り、最適なモデルをインテリジェントに選択 | ほとんどの日常的な開発作業。推奨デフォルト       | 約 1.0x   |
| `"ultimate"`    | アルティメット    | エキスパートレベルの深い推論と思考能力               | 複雑なシステム設計と難しい分析             | 約 1.6x   |
| `"performance"` | パフォーマンス    | 高度な推論と高品質な出力                      | コア実装、アーキテクチャ設計、リファクタリング     | 約 1.1x   |
| `"efficient"`   | エフィシェント    | コスト効率の良い標準的な推論                    | 基本的なコード生成、ユニットテスト、日常的な Q\&A | 約 0.3x   |
| `"lite"`        | ライト        | 基本的な推論、無料で使用可能                    | 簡易検証、シンプルなロジック、簡単な質問        | 0x       |

Agent では 2 つの特殊な形式もサポートしています：

| 値           | 説明                                               |
| ----------- | ------------------------------------------------ |
| `"inherit"` | メインセッションのモデルを継承。通常 `supported_agents()` には反映されない |
| 完全なモデル ID   | 現在の CLI / バックエンドがサポートするモデル ID を直接指定              |

<div id="mcpservers" />

<div id="agentdefinition-mcpservers" />

#### `mcpServers`

```python theme={null}
mcpServers: list[str | dict[str, Any]] | None
```

この Agent が利用可能な MCP サーバーを制限または追加します。各エントリはセッションレベルのサーバー名、またはインラインのサーバー設定マッピングです。

セッションレベルの MCP サーバーを参照：

```python theme={null}
options = QoderAgentOptions(
    mcp_servers={
        "orders": {
            "command": "python",
            "args": ["servers/orders.py"],
        },
    },
    allowed_tools=["Agent"],
    agents={
        "support": AgentDefinition(
            description="Answers support questions using order tools.",
            prompt="Use order tools when needed and return a concise answer.",
            mcpServers=["orders"],
            tools=["mcp__orders__lookup_order"],
        ),
    },
)
```

特定の Agent 専用の MCP サーバーを設定：

```python theme={null}
AgentDefinition(
    description="Searches the internal knowledge base.",
    prompt="Search the knowledge base and cite relevant entries.",
    mcpServers=[
        {
            "kb": {
                "command": "python",
                "args": ["servers/kb.py"],
            },
        },
    ],
    tools=["mcp__kb__search"],
)
```

特定の MCP ツールのみ公開したい場合は、`tools=["mcp__server__tool"]` も併せて設定し、サーバーの全ツールを Agent に公開しないようにしてください。

<div id="skills" />

#### `skills`

Agent コンテキストにプリロードするスキル名のリスト。プレーンなスキル名とプラグイン修飾名の両方をサポートします。

```python theme={null}
skills=["review", "sdk-test-plugin:sdk-echo"]
```

セッションレベルのスキル動作については [Skills](/ja/cli/sdk/python/skills) を参照してください。

<div id="initialprompt" />

#### `initialPrompt`

`QoderAgentOptions.agent` を通じてこの Agent がメインセッション Agent になるとき、最初のユーザー入力として自動送信されます。

```python theme={null}
initialPrompt="Start by scanning authentication and session management code."
```

このフィールドはメインセッション Agent でのみ有効です。`Agent` ツール経由でサブエージェントとして呼び出される場合は無視されます。

<div id="maxturns" />

<div id="agentdefinition-maxturns" />

#### `maxTurns`

Agent の最大 API ターン数を制限します。コスト、実行時間、ループのリスクを制御するために使用します。

```python theme={null}
maxTurns=6
```

<div id="effort" />

<div id="agentdefinition-effort" />

#### `effort`

```python theme={null}
EffortLevel = Literal["low", "medium", "high", "max"]
```

Agent の推論 effort レベルを制御します。`effort` が高いほど、複雑なレビュー、アーキテクチャ分析、リスクの高い変更に通常適していますが、レイテンシとトークン使用量が増加します。

<div id="agentdefinition-permissionmode" />

#### `permissionMode`

この Agent 内のツール実行に対する権限モードを制御します。セッションレベルの `permission_mode` と同じ意味を持ちますが、スコープはこの Agent に限定されます。セッションレベルの権限チェーン、`allowed_tools` / `disallowed_tools` / `can_use_tool` の優先順位、例については [権限制御](/ja/cli/sdk/python/permissions#デフォルトポリシーの制御permission_mode) を参照してください。

```python theme={null}
PermissionMode = Literal[
    "default",
    "acceptEdits",
    "plan",
    "bypassPermissions",
    "yolo",
    "dontAsk",
    "auto",
]
```

| 値                     | 意味                                                                    | 適用                                      |
| --------------------- | --------------------------------------------------------------------- | --------------------------------------- |
| `"default"`           | 標準的な権限動作。ツール呼び出しは依然としてツールセット、許可 / 拒否ルール、ランタイム承認、または CLI のデフォルトポリシーを通過 | ほとんどのインタラクティブなサブエージェント                  |
| `"acceptEdits"`       | ファイル編集操作を自動的に受け入れる。他のセンシティブな操作は引き続き権限フローに従う                           | ワークスペースファイルの変更が承認されているサブエージェント          |
| `"bypassPermissions"` | 権限チェックをスキップ。高リスクモード。通常は信頼された自動化またはテスト環境のみ                             | 制御された CI、一時検証、ワンオフ自動化                   |
| `"yolo"`              | `"bypassPermissions"` の互換エイリアス。同様に権限チェックをスキップ                         | 古い設定との互換性。新規コードでは推奨されない                 |
| `"plan"`              | プランモード。先にプランを生成するのに適しており、デフォルトでは実際の変更を行わない                            | 計画、設計、レビュー、またはサブエージェントがファイルを変更すべきでないケース |
| `"dontAsk"`           | インタラクティブな確認をしない。事前認可されていないか、ルールで許可されていない操作は拒否                         | 非インタラクティブ環境、またはプロンプトではなく失敗すべきワークフロー     |
| `"auto"`              | ランタイム能力が許可または拒否を自動決定                                                  | 確認による中断を減らしつつ、ランタイム判断を保持                |

権限のセマンティクスについては [権限制御](/ja/cli/sdk/python/permissions) を参照してください。

<div id="agentinfo" />

### `AgentInfo`

`QoderSDKClient.supported_agents()` が返す Agent サマリ。

```python theme={null}
class AgentInfo(TypedDict):
    name: str
    description: str
    model: NotRequired[str | None]
```

Python SDK は現在 `AgentInfo` という名前の TypedDict をエクスポートしていません。`supported_agents()` の戻り値の型は `list[dict[str, Any]]` です。上記の構造は、実際に返される dict の安定したフィールド規約です。

| フィールド         | 型             | 説明                                                 |
| ------------- | ------------- | -------------------------------------------------- |
| `name`        | `str`         | Agent 名                                            |
| `description` | `str`         | Agent の用途説明                                        |
| `model`       | `str \| None` | Agent のモデルオーバーライド。未設定または `model="inherit"` の場合は通常空 |

```python theme={null}
from qoder_agent_sdk import AgentDefinition, QoderAgentOptions, QoderSDKClient


options = QoderAgentOptions(
    agents={
        "reviewer": AgentDefinition(
            description="Reviews code quality.",
            prompt="Review code and report findings.",
        ),
    },
)

client = QoderSDKClient(options=options)
await client.connect("List agents.")
agents = client.supported_agents()
await client.disconnect()
```

返されるリストには、`agents` で登録された Agent や、現在の CLI が検出した組み込み、プロジェクト、ユーザー、プラグインの Agent が含まれる場合があります。実際に利用可能なエントリは qodercli のバージョンと現在の設定に依存します。

<div id="context-and-invocation-boundaries" />

<div id="contextandinvocationboundaries" />

### Context and Invocation Boundaries

* サブエージェントは独立したコンテキストを使用し、親セッションの完全な履歴を受け取りません。
* 親セッションからサブエージェントに渡される主要な情報は、`Agent` ツールに供給されるタスクプロンプトです。
* サブエージェントの中間ツール結果は親セッションに直接入りません。親セッションはサブエージェントの最終応答を受け取ります。
* サブエージェントは自身のサブエージェントを生成できないため、サブエージェントの `tools` に `Agent` を含めないでください。
* `initialPrompt` は `agent` で指定されたメインセッション Agent でのみ有効です。

<div id="related-documentation" />

<div id="relateddocumentation" />

### Related Documentation

* [サブエージェント利用ガイド](/ja/cli/sdk/python/agents)
* [Tools リファレンス](#tools-reference)
* [MCP 連携](/ja/cli/sdk/python/mcp)
* [権限制御](/ja/cli/sdk/python/permissions)
* [Skills](/ja/cli/sdk/python/skills)

<div id="model-policy" />

<div id="modelpolicy" />

### Model Policy

`query()` の動的なモデル選択機能。2 つのモード: 固定モデル（`resolve_model` を渡さず `options.model` またはバックエンドのデフォルトを使用）と動的コールバック（`resolve_model` を渡し、すべての LLM 呼び出し前にコールバックがモデルを決定）。概念、トリガー、エラー処理の詳細は [Model Policy](/ja/cli/sdk/python/model-policy) を参照。

<div id="optionsresolve_model" />

<div id="options-resolve_model" />

#### `options.resolve_model`

**型:** [`ModelPolicyProvider`](#modelpolicyprovider)

動的コールバックモードのエントリーポイント。一度渡すと動的コールバックモードが有効になり、SDK は LLM リクエストごとにこのコールバックを呼び出してモデルを取得する。コールバックが返した `model` がそのリクエストの最終モデルであり、**自動フォールバックは存在しない**。

<div id="optionsresolve_model_timeout_ms" />

<div id="options-resolve_model_timeout_ms" />

#### `options.resolve_model_timeout_ms`

**型:** `int`、デフォルト `500`

コールバックのタイムアウト（ミリ秒）。タイムアウトすると [`ModelPolicyTimeoutError`](#modelpolicytimeouterror) がスローされ、クエリは失敗する（フォールバックなし）。`resolve_model` を渡したときのみ有効。

<div id="modelpolicyprovider" />

### `ModelPolicyProvider`

コールバック関数のシグネチャ。同期でも非同期でもよい。

```python theme={null}
from typing import Awaitable, Callable

ModelPolicyProvider = Callable[
    ["ModelPolicyContext"],
    "ModelPolicyResult | Awaitable[ModelPolicyResult]",
]
```

トリガーシナリオは [`QoderModelPurpose`](#qodermodelpurpose) によって区別される:

| シナリオ         | `purpose`     | 備考                                                                      |
| ------------ | ------------- | ----------------------------------------------------------------------- |
| メイン会話        | `'main'`      | ターンやツールごとに再呼び出し — セッション中に何度もトリガーされ得る                                    |
| サブエージェント     | `'subagent'`  | サブエージェントは同じプロバイダを共有                                                     |
| WebFetch ツール | `'web_fetch'` | WebFetch がコンテンツを取得した後、要約用に 2 回目の LLM 呼び出しが行われる                          |
| ImageGen ツール | `'image_gen'` | 画像生成モデルの選択に使用                                                           |
| コンテキスト圧縮     | `'compact'`   | 圧縮開始前に、圧縮用モデルをコールバックに問い合わせる                                             |
| BYOK         | 任意            | `model` を [`CustomModel`](#custommodel) オブジェクトに設定するとサードパーティ LLM へルーティング |

挙動上の注意:

* コールバックは 1 セッション内で何度もトリガーされ得る（各ターン / ツール / サブタスク前に再呼び出し）。
* コールバックが返した `model` がそのリクエストの最終モデルであり、SDK は再検証しない。
* 例外をスローしたり空の `model` を返した場合、クエリは直ちに失敗する。[Model Policy — エラー処理](/ja/cli/sdk/python/model-policy#エラー処理) を参照。

<div id="modelpolicycontext" />

### `ModelPolicyContext`

コールバック呼び出しのたびに渡されるコンテキスト。

```python theme={null}
class ModelPolicyContext(TypedDict, total=False):
    purpose: str  # QoderModelPurpose
    sessionId: str
    agentId: str
    turnIndex: int
    availableModels: list[ModelInfo]
```

| フィールド             | 型                                         | 必須 | 説明                                                               |
| ----------------- | ----------------------------------------- | -- | ---------------------------------------------------------------- |
| `purpose`         | [`QoderModelPurpose`](#qodermodelpurpose) | はい | この LLM 呼び出しの用途                                                   |
| `sessionId`       | `str`                                     | はい | 現在のセッション ID。セッション中のコールバック呼び出しで同じ値が渡されるため、キャッシュ / テレメトリのキーとして利用可能 |
| `agentId`         | `str`                                     | はい | 呼び出しを開始した Agent の識別子                                             |
| `turnIndex`       | `int`                                     | はい | 現在のターンインデックス                                                     |
| `availableModels` | [`ModelInfo`](#modelinfo)`[]`             | はい | アカウントが現在リアルタイムで利用可能なモデル（CLI が `get_model_policy` リクエストごとにリストを送る） |

<div id="qodermodelpurpose" />

### `QoderModelPurpose`

```python theme={null}
from typing import Literal

QoderModelPurpose = Literal[
    "main",
    "plan",
    "task",
    "compact",
    "title",
    "suggestion",
    "generate",
    "hook_prompt",
    "subagent",
    "web_fetch",
    "image_gen",
    "compression",
    "utility",
]
```

| 値             | トリガーシナリオ                           |
| ------------- | ---------------------------------- |
| `'main'`      | メイン会話の LLM 呼び出し                    |
| `'subagent'`  | サブエージェント呼び出し                       |
| `'web_fetch'` | WebFetch ツールがトリガーする 2 回目の LLM 呼び出し |
| `'image_gen'` | ImageGen ツールがトリガーする画像生成呼び出し        |
| `'compact'`   | コンテキスト圧縮 / 要約                      |

<div id="modelpolicyresult" />

### `ModelPolicyResult`

コールバックの戻り値。

```python theme={null}
class ModelPolicyResult(TypedDict, total=False):
    model: str | CustomModel
    parameters: dict[str, Any]
```

| フィールド        | 型                                      | 必須  | 説明                                          |
| ------------ | -------------------------------------- | --- | ------------------------------------------- |
| `model`      | `str \| `[`CustomModel`](#custommodel) | はい  | 文字列: モデル識別子。オブジェクト: BYOK 認証情報 + モデル識別子      |
| `parameters` | `dict[str, Any]`                       | いいえ | モデルパラメータの上書き（例: `temperature`、`max_tokens`） |

`model` の形式:

* **文字列** — バックエンドがサポートする任意のモデル ID（`auto` / `performance` / `glm51` など）。有効な値の正確な集合は [`client.get_available_models()`](#clientget_available_models) がリアルタイムで返す。**空でない** こと。さもなくばクエリは失敗する。
* **`CustomModel` オブジェクト**（BYOK） — SDK はオブジェクトの `model` フィールドをこの呼び出しのモデル識別子として抽出し、残りのフィールドを認証情報として CLI へ転送し、サードパーティ LLM へルーティングする。

<div id="custommodel" />

### `CustomModel`

BYOK 認証情報。`resolve_model` コールバック内で `model` フィールドにこのオブジェクトを直接設定すると、その LLM リクエストはサードパーティプロバイダへルーティングされる。

```python theme={null}
class CustomModel(TypedDict, total=False):
    provider: str
    model: str
    api_key: str
    url: str
    style: str  # "openai" | "anthropic"
```

| フィールド      | 型     | 必須  | 説明                                                               |
| ---------- | ----- | --- | ---------------------------------------------------------------- |
| `provider` | `str` | はい  | プロバイダキー — [`BYOKProviderInfo.key`](#byokproviderinfo) と一致する必要がある |
| `model`    | `str` | はい  | モデル識別子 — SDK がこの呼び出しのモデル ID として抽出                                |
| `api_key`  | `str` | はい  | ユーザーが提供する API キー                                                 |
| `url`      | `str` | いいえ | デフォルトのベース URL を上書き                                               |
| `style`    | `str` | いいえ | 上流プロトコルスタイル。例: `"openai"` / `"anthropic"`。デフォルトは `"openai"`      |

注意:

* `provider` はカタログ内の `key` と一致する必要がある。さもなくばバックエンド認証が失敗する。
* `api_key` が誤っていると認証が失敗し、クエリは直ちに失敗する（動的コールバックモードはフォールバックしない）。
* BYOK 呼び出しは `total_cost_usd` をプラットフォーム上で 0 として報告する。トークン使用量はそのまま報告され、プロバイダ側で課金される。

<div id="byok-catalog-types" />

<div id="byokcatalogtypes" />

### BYOK Catalog Types

[`client.list_byok_providers()`](#clientlist_byok_providers) が返すプロバイダ / モデルカタログ。

```python theme={null}
class SDKControlGetByokConfigResponse(TypedDict, total=False):
    providers: list[BYOKProviderInfo]


class BYOKProviderInfo(TypedDict, total=False):
    key: str
    display_name: str
    api_key_url: str
    url: str
    fields: list[BYOKFieldInfo]
    types: list[BYOKModelTypeInfo]


class BYOKFieldInfo(TypedDict, total=False):
    key: str
    display_name: str
    type: str  # e.g. "free_input"
    mandatory: bool


class BYOKModelTypeInfo(TypedDict, total=False):
    key: str
    display_name: str
    models: list[BYOKModelInfo]


class BYOKModelInfo(TypedDict, total=False):
    key: str
    display_name: str
    is_vl: bool
    is_reasoning: bool
    format: str
    max_input_tokens: int
```

<div id="byokproviderinfo" />

#### `BYOKProviderInfo`

| フィールド          | 型                         | 説明                                          |
| -------------- | ------------------------- | ------------------------------------------- |
| `key`          | `str`                     | プロバイダキー — BYOK の `CustomModel.provider` に設定 |
| `display_name` | `str`                     | 表示名                                         |
| `api_key_url`  | `str`                     | ユーザーが API キーを取得する URL                       |
| `url`          | `str`                     | 推論リクエスト用のベース URL                            |
| `fields`       | `list[BYOKFieldInfo]`     | プロバイダがユーザーに入力を要求するフィールド一覧                   |
| `types`        | `list[BYOKModelTypeInfo]` | このプロバイダ配下のモデルグループ                           |

<div id="byokfieldinfo" />

#### `BYOKFieldInfo`

| フィールド          | 型      | 説明                          |
| -------------- | ------ | --------------------------- |
| `key`          | `str`  | フィールドキー（例: `api_key`）       |
| `display_name` | `str`  | ユーザーに表示される名前                |
| `type`         | `str`  | フィールドタイプ（例: `"free_input"`） |
| `mandatory`    | `bool` | 必須かどうか                      |

<div id="byokmodeltypeinfo" />

#### `BYOKModelTypeInfo`

| フィールド          | 型                     | 説明                                   |
| -------------- | --------------------- | ------------------------------------ |
| `key`          | `str`                 | グループキー。一般的な値: `cp` / `tp` / `pg`（任意） |
| `display_name` | `str`                 | グループ表示名                              |
| `models`       | `list[BYOKModelInfo]` | グループ内のモデル                            |

<div id="byokmodelinfo" />

#### `BYOKModelInfo`

| フィールド              | 型      | 説明                               |
| ------------------ | ------ | -------------------------------- |
| `key`              | `str`  | モデル ID — `CustomModel.model` に設定 |
| `display_name`     | `str`  | 表示名                              |
| `is_vl`            | `bool` | ビジョン / マルチモーダル入力をサポートするか         |
| `is_reasoning`     | `bool` | 推論モデルかどうか                        |
| `format`           | `str`  | 上流プロトコル形式（例: `openai`）           |
| `max_input_tokens` | `int`  | 最大入力トークン数                        |

<div id="modelinfo" />

### `ModelInfo`

[`client.get_available_models()`](#clientget_available_models) が返す利用可能モデルのサマリ。[`ModelPolicyContext.availableModels`](#modelpolicycontext) の要素型としても使用される。

```python theme={null}
class ModelInfo(TypedDict, total=False):
    value: str
    displayName: str
    isEnabled: bool
```

| フィールド         | 型                   | 説明                                                                                                           |
| ------------- | ------------------- | ------------------------------------------------------------------------------------------------------------ |
| `value`       | `str`               | モデル識別子。[`ModelPolicyResult.model`](#modelpolicyresult) や [`client.set_model()`](#clientset_model) の引数として使用可能 |
| `displayName` | `str`               | 表示名                                                                                                          |
| `isEnabled`   | `bool \| undefined` | 現在利用可能かどうか。`undefined` は利用可能として扱われる                                                                          |

<div id="modelpolicytimeouterror" />

### `ModelPolicyTimeoutError`

```python theme={null}
class ModelPolicyTimeoutError(Exception): ...
```

`resolve_model` コールバックが `options.resolve_model_timeout_ms` 以内に返らなかった場合に SDK がスローする。クエリは直ちに失敗し、フォールバックはない。

<div id="clientset_model" />

<div id="client-set_model" />

### `client.set_model()`

```python theme={null}
async def set_model(self, model: str | None = None) -> None: ...
```

固定モデルモードにおいて実行時にモデルを切り替える。次回の LLM 呼び出しから有効。固定モデルモードでのみ有効で、動的コールバックモードで呼び出してもコールバックの結果を上書きしない。有効なモデル ID は [`ModelInfo.value`](#modelinfo) を参照。

<div id="clientget_available_models" />

<div id="client-get_available_models" />

### `client.get_available_models()`

```python theme={null}
async def get_available_models(self) -> list[ModelInfo]: ...
```

現在のアカウントが利用可能な最新のモデル一覧をリアルタイムで取得する。常に最新の結果を返し、キャッシュは行わない。一時的に取得できない場合は空配列を返す（例外はスローしない）。動的コールバックモードでは [`ModelPolicyContext.availableModels`](#modelpolicycontext) が同じ最新リストを既に持つため、明示的にこのメソッドを呼ぶ必要はない。

<div id="clientlist_byok_providers" />

<div id="client-list_byok_providers" />

### `client.list_byok_providers()`

```python theme={null}
async def list_byok_providers(self) -> list[BYOKProviderInfo] | None: ...
```

現在のアカウントで利用可能な BYOK プロバイダ / モデルカタログを配列で返す:

* `None` を返す: CLI がこの API をサポートしていない（グレースフルフォールバック、例外なし）。
* 配列を返す（空の可能性あり）: 現在のアカウントで利用可能なプロバイダ一覧（空配列はアカウントが BYOK を有効化していないことを意味する）。

フィールドの意味は [BYOK カタログ型](#byok-catalog-types) を参照。

<div id="canusetool" />

### `CanUseTool`

ホスト定義のカスタムツール権限承認コールバック。

```python theme={null}
from collections.abc import Awaitable, Callable
from typing import Any


CanUseTool = Callable[
    [str, dict[str, Any], ToolPermissionContext],
    Awaitable[PermissionResult],
]
```

<div id="toolpermissioncontext" />

#### `ToolPermissionContext`

```python theme={null}
import asyncio
from dataclasses import dataclass, field
from typing import Any


@dataclass
class ToolPermissionContext:
    signal: asyncio.Event | None = None
    suggestions: list[Any] = field(default_factory=list)
    blocked_path: str | None = None
    decision_reason: str | None = None
    decision_reason_type: str | None = None
    classifier_approvable: bool | None = None
    title: str | None = None
    display_name: str | None = None
    description: str | None = None
    tool_use_id: str | None = None
    agent_id: str | None = None
    exit_plan_mode: ExitPlanModeApprovalDetails | None = None
```

| フィールド                                    | 型                                     | 説明                             |
| :--------------------------------------- | :------------------------------------ | :----------------------------- |
| `signal`                                 | `asyncio.Event \| None`               | キャンセル時にセットされる                  |
| `suggestions`                            | `list[Any]`                           | CLI からの権限更新提案                  |
| `blocked_path`                           | `str \| None`                         | 認可をトリガーするファイルパス（ファイル関連シナリオのみ）  |
| `decision_reason`                        | `str \| None`                         | CLI からの人間可読な認可理由               |
| `decision_reason_type`                   | `str \| None`                         | 権限理由の分類                        |
| `classifier_approvable`                  | `bool \| None`                        | 現在の呼び出しがランタイム分類器によって自動承認可能かどうか |
| `title` / `display_name` / `description` | `str \| None`                         | 実行時に生成された人間可読な認可テキスト           |
| `tool_use_id`                            | `str \| None`                         | このツール呼び出しの ID                  |
| `agent_id`                               | `str \| None`                         | 呼び出しを開始したサブエージェント ID           |
| `exit_plan_mode`                         | `ExitPlanModeApprovalDetails \| None` | プランモード終了時の承認詳細                 |

完全な使用方法と例は [Permission Control](/ja/cli/sdk/python/permissions#canusetool) を参照。

<div id="permissionmode" />

### `PermissionMode`

```python theme={null}
PermissionMode = Literal[
    "default",
    "acceptEdits",
    "bypassPermissions",
    "yolo",
    "plan",
    "dontAsk",
    "auto",
]
```

| 値                     | 意味                                                                                 | 適用対象                         |
| :-------------------- | :--------------------------------------------------------------------------------- | :--------------------------- |
| `"default"`           | 標準的な権限挙動。ツール呼び出しは `tools`、allow / deny ルール、動的承認、またはランタイムポリシーで処理                    | 多くの対話セッション                   |
| `"acceptEdits"`       | ファイル編集操作を自動承認。その他の機微な操作は通常の権限フローに従う                                                | ワークスペース変更が承認済みのセッション         |
| `"bypassPermissions"` | 権限チェックをスキップ。`allow_dangerously_skip_permissions=True` も併設する必要あり                    | 信頼された自動化やテスト環境               |
| `"yolo"`              | `"bypassPermissions"` の互換エイリアス。`allow_dangerously_skip_permissions=True` も併設する必要あり | 旧設定との互換用。新規コードでは非推奨          |
| `"plan"`              | プランモード。まずプランを生成する用途に適し、デフォルトでは実変更を行わない                                             | 計画、設計、レビュー                   |
| `"dontAsk"`           | 対話的に問わず、事前認可されないかルールで許可されない操作は拒否                                                   | 非対話環境、またはプロンプトせず失敗させたいワークフロー |
| `"auto"`              | ランタイム能力が許可 / 拒否を自動決定。安全なワークスペースのファイル編集は自動許可される可能性あり                                | 確認の中断を減らしつつランタイム判断を残したい場合    |

権限チェーンの詳細は [Permission Control](/ja/cli/sdk/python/permissions) を参照。

<div id="permissionresult" />

### `PermissionResult`

`CanUseTool` の戻り値。

```python theme={null}
from dataclasses import dataclass
from typing import Any, Literal


@dataclass
class PermissionResultAllow:
    behavior: Literal["allow"] = "allow"
    updated_input: dict[str, Any] | None = None
    updated_permissions: list[PermissionUpdate | dict[str, Any]] | None = None
    decision_classification: PermissionDecisionClassification | None = None


@dataclass
class PermissionResultDeny:
    behavior: Literal["deny"] = "deny"
    message: str = ""
    interrupt: bool = False
    decision_classification: PermissionDecisionClassification | None = None


PermissionResult = PermissionResultAllow | PermissionResultDeny
```

`allow.updated_input` を変更すると、ツールが実際に受け取るパラメータが置き換えられる。`deny.interrupt=True` は拒否に加えて Agent を中断する。

`can_use_tool` が受け取る `tool_name` は完全なツール名。例: `"Bash"`、`"Read"`、`"mcp__orders__lookup_order"`。

<div id="mcpserverconfig" />

### `McpServerConfig`

MCP サーバー設定。`QoderAgentOptions.mcp_servers` に渡す。

```python theme={null}
McpServerConfig = (
    McpStdioServerConfig
    | McpSSEServerConfig
    | McpHttpServerConfig
    | McpSdkServerConfig
)
```

<div id="mcpstdioserverconfig" />

#### `McpStdioServerConfig`

```python theme={null}
class McpStdioServerConfig(TypedDict):
    type: NotRequired[Literal["stdio"]]
    command: str
    args: NotRequired[list[str]]
    env: NotRequired[dict[str, str]]
    tools: NotRequired[list[McpServerToolPolicy]]
```

<div id="mcpsseserverconfig" />

#### `McpSSEServerConfig`

```python theme={null}
class McpSSEServerConfig(TypedDict):
    type: Literal["sse"]
    url: str
    headers: NotRequired[dict[str, str]]
    tools: NotRequired[list[McpServerToolPolicy]]
```

<div id="mcphttpserverconfig" />

#### `McpHttpServerConfig`

```python theme={null}
class McpHttpServerConfig(TypedDict):
    type: Literal["http"]
    url: str
    headers: NotRequired[dict[str, str]]
    tools: NotRequired[list[McpServerToolPolicy]]
```

<div id="mcpsdkserverconfig" />

#### `McpSdkServerConfig`

```python theme={null}
class McpSdkServerConfig(TypedDict):
    type: Literal["sdk"]
    name: str
    instance: McpServer
    tools: NotRequired[list[McpServerToolPolicy]]
```

`create_sdk_mcp_server()` ファクトリが返す。[MCP - インプロセスサーバー](/ja/cli/sdk/python/mcp#インプロセスサーバー推奨) を参照。

<div id="mcpservertoolpolicy" />

#### `McpServerToolPolicy`

```python theme={null}
class McpServerToolPolicy(TypedDict):
    name: str
    permission_policy: Literal["always_allow", "always_ask", "always_deny"]
```

<div id="sdkpluginconfig" />

### `SdkPluginConfig`

ローカルプラグインを読み込む。

```python theme={null}
class SdkPluginConfig(TypedDict):
    type: Literal["local"]
    path: str
```

| フィールド  | 型         | 説明                     |
| :----- | :-------- | :--------------------- |
| `type` | `"local"` | 現在は local のみサポート       |
| `path` | `str`     | プラグインディレクトリへの絶対または相対パス |

<div id="settingsource" />

### `SettingSource`

どのファイルシステム設定を読み込むかを制御。

```python theme={null}
SettingSource = Literal["user", "project", "local"]
```

| 値           | 意味                         | 場所                           |
| :---------- | :------------------------- | :--------------------------- |
| `"user"`    | ユーザーレベルのグローバル設定            | `~/.qoder/settings.json`     |
| `"project"` | プロジェクト共有設定（バージョン管理対象）      | `.qoder/settings.json`       |
| `"local"`   | プロジェクトローカル設定（gitignore 対象） | `.qoder/settings.local.json` |

省略時は CLI のデフォルトに従いすべてのソースが読み込まれる。`[]` を渡すと完全にスキップされる。

<div id="tools-reference" />

<div id="toolsreference" />

## Tools Reference

このページでは、安定したツール関連 API、組み込みツール一覧、および型定義をまとめます。利用パスやシナリオについては [ツール利用ガイド](/ja/cli/sdk/python/tools) を参照してください。

> 注: Python SDK は現時点で、TypeScript SDK の `BashInput`、`FileReadInput`、`ToolInputSchemas` などの組み込みツール入力 / 出力型コレクションをエクスポートしていません。実装状況は該当セクションで明示しています。

<div id="toolconfig" />

### `ToolConfig`

TypeScript SDK は、一部の組み込みツールの挙動を設定するために `options.toolConfig` を提供しています：

```typescript theme={null}
type ToolConfig = {
  askUserQuestion?: {
    previewFormat?: "markdown" | "html";
  };
};
```

Python SDK は現時点で、これに相当する `QoderAgentOptions.tool_config` フィールドをエクスポートしていません。`AskUserQuestion` は引き続き、`tools`、`allowed_tools`、`disallowed_tools`、`can_use_tool`、フックマッチャーで実行時ツール名として利用できます。

<div id="built-in-tool-list" />

<div id="builtintoollist" />

### Built-in Tool List

`tools`、`allowed_tools`、`disallowed_tools`、`can_use_tool`、フックマッチャー、および Agent ツール許可リストでは、組み込みツールは下表の実行時ツール名を使用します。

| カテゴリ         | ツール名               | 説明                | Python SDK の状況      |
| ------------ | ------------------ | ----------------- | ------------------- |
| コマンド実行       | `Bash`             | シェルコマンドを実行        | 権限 / ツールスコープ設定で利用可能 |
| ファイル操作       | `Read`             | ファイル内容を読み取り       | 権限 / ツールスコープ設定で利用可能 |
| ファイル操作       | `Edit`             | 文字列マッチでファイルを編集    | 権限 / ツールスコープ設定で利用可能 |
| ファイル操作       | `Write`            | ファイルの作成または上書き     | 権限 / ツールスコープ設定で利用可能 |
| 検索           | `Glob`             | ファイル名パターンで検索      | 権限 / ツールスコープ設定で利用可能 |
| 検索           | `Grep`             | コンテンツ正規表現で検索      | 権限 / ツールスコープ設定で利用可能 |
| ネットワーク       | `WebFetch`         | URL の内容を取得・処理     | 権限 / ツールスコープ設定で利用可能 |
| ネットワーク       | `WebSearch`        | ウェブ検索             | 権限 / ツールスコープ設定で利用可能 |
| エージェント       | `Agent`            | サブエージェントを呼び出し     | 権限 / ツールスコープ設定で利用可能 |
| インタラクション     | `AskUserQuestion`  | ユーザーへの質問          | 権限 / ツールスコープ設定で利用可能 |
| ノートブック       | `NotebookEdit`     | ノートブックセルを編集       | 権限 / ツールスコープ設定で利用可能 |
| バックグラウンドタスク  | `TaskOutput`       | バックグラウンドタスクへ出力を送信 | 権限 / ツールスコープ設定で利用可能 |
| バックグラウンドタスク  | `TaskStop`         | バックグラウンドタスクを停止    | 権限 / ツールスコープ設定で利用可能 |
| プラン / ワークツリー | `ExitPlanMode`     | プランモードを終了         | 権限 / ツールスコープ設定で利用可能 |
| プラン / ワークツリー | `EnterWorktree`    | git ワークツリーに入る     | 権限 / ツールスコープ設定で利用可能 |
| プラン / ワークツリー | `ExitWorktree`     | ワークツリーを抜ける        | 権限 / ツールスコープ設定で利用可能 |
| 設定           | `Config`           | 設定の読み書き           | 権限 / ツールスコープ設定で利用可能 |
| Todo         | `TodoWrite`        | Todo 項目を管理        | 権限 / ツールスコープ設定で利用可能 |
| MCP リソース     | `ListMcpResources` | MCP リソースを一覧表示     | 権限 / ツールスコープ設定で利用可能 |
| MCP リソース     | `ReadMcpResource`  | MCP リソースを読み取り     | 権限 / ツールスコープ設定で利用可能 |
| MCP 呼び出し     | `Mcp`              | 汎用 MCP ツール呼び出し    | 権限 / ツールスコープ設定で利用可能 |

カスタム MCP ツール名は次の形式を使用します：

```text theme={null}
mcp__{serverName}__{toolName}
```

<div id="tool" />

### `tool()`

SDK MCP ツール定義を作成します。Python 版はデコレータ形式で、ハンドラは `@tool(...)` でラップされます。

```python theme={null}
from collections.abc import Awaitable, Callable
from typing import Any

from mcp.types import ToolAnnotations


def tool(
    name: str,
    description: str,
    input_schema: type | dict[str, Any],
    annotations: ToolAnnotations | None = None,
) -> Callable[[Callable[..., Awaitable[dict[str, Any]]]], SdkMcpTool[Any]]:
    ...
```

| パラメータ          | 型                         | 必須  | 意味                              | 現在の Qoder の挙動                                                          |
| -------------- | ------------------------- | --- | ------------------------------- | ---------------------------------------------------------------------- |
| `name`         | `str`                     | はい  | 現在の MCP サーバー内でのツールの一意な識別子       | モデルから見えるフルツール名 `mcp__{serverName}__{name}` を構成。登録時に非空であることが必須          |
| `description`  | `str`                     | はい  | モデルに示すツール説明 — いつ使うか、何をするか、何を返すか | ツール一覧にそのまま渡され、モデルが正しく呼び出せるかに直接影響する。登録時に非空であることが必須                      |
| `input_schema` | `type \| dict[str, Any]`  | はい  | ツールの入力パラメータを定義                  | SDK が MCP 入力スキーマを生成。単純な dict、`TypedDict`、または完全な JSON Schema dict をサポート |
| `annotations`  | `ToolAnnotations \| None` | いいえ | 追加のツールメタデータ                     | SDK が annotations を MCP サーバーに登録。権限設定を置き換えるものではない                       |

`tool()` 自体はツールを定義するのみで、デコレートされた async ハンドラがツール呼び出し時に実行される関数です。`name`、`description`、ツール名の重複などの登録制約は、`create_sdk_mcp_server()` でツール登録時に検証されます。

<div id="input_schema" />

#### `input_schema`

Python SDK には TypeScript SDK の `AnyZodRawShape` / `InferShape` はありません。Python 版の `input_schema` は次の形式をサポートします：

```python theme={null}

# Simple dict: all fields required
{"query": str, "limit": int}

# Use Annotated to add a field description
{"query": Annotated[str, "Search keywords"]}

# TypedDict: supports NotRequired
class SearchInput(TypedDict):
    query: str
    limit: NotRequired[int]

# Complete JSON Schema dict
{
    "type": "object",
    "properties": {
        "query": {"type": "string"},
        "source": {"type": "string", "enum": ["docs", "wiki"]},
    },
    "required": ["query"],
}
```

一般的な Python 型の変換：

| Python 形式             | JSON Schema の意味                                     |
| --------------------- | --------------------------------------------------- |
| `str`                 | `{"type": "string"}`                                |
| `int`                 | `{"type": "integer"}`                               |
| `float`               | `{"type": "number"}`                                |
| `bool`                | `{"type": "boolean"}`                               |
| `list[T]`             | array、`items` 付き                                    |
| `dict`                | object                                              |
| `Annotated[T, "..."]` | `T` のスキーマに `description` を追加                        |
| `TypedDict`           | object; required / NotRequired に基づいて `required` を生成 |

<div id="typescript-only-schema-helper-types" />

<div id="typescriptonlyschemahelpertypes" />

#### TypeScript-only schema helper types

| TypeScript 参照型   | Python SDK の状況 | Python での同等機能                                                  |
| ---------------- | -------------- | -------------------------------------------------------------- |
| `AnyZodRawShape` | 未実装 / 未エクスポート  | `dict[str, type]`、`TypedDict`、または完全な JSON Schema dict を使用      |
| `InferShape`     | 未実装 / 未エクスポート  | ハンドラは `args` dict を受け取る。静的型付けが必要なら、ビジネス側で独自の `TypedDict` を宣言する |
| `ToolExtras`     | 未実装 / 未エクスポート  | Python では、`annotations` を `@tool()` の第 4 引数として直接渡す             |

<div id="sdkmcptool" />

#### `SdkMcpTool`

```python theme={null}
from collections.abc import Awaitable, Callable
from dataclasses import dataclass
from typing import Any, Generic, TypeVar

from mcp.types import ToolAnnotations


T = TypeVar("T")


@dataclass
class SdkMcpTool(Generic[T]):
    name: str
    description: str
    input_schema: type[T] | dict[str, Any]
    handler: Callable[..., Awaitable[dict[str, Any]]]
    annotations: ToolAnnotations | None = None
```

`@tool()` デコレータは `SdkMcpTool` を返します。通常は手動で構築する必要はありません。

<div id="toolinvocationcontext" />

#### `ToolInvocationContext`

```python theme={null}
import asyncio
from dataclasses import dataclass, field


@dataclass
class ToolInvocationContext:
    signal: asyncio.Event = field(default_factory=asyncio.Event)
```

ハンドラは 1 つまたは 2 つのパラメータを取れます：

```python theme={null}
@tool("watch", "Watch a counter.", {"max": int})
async def watch(args, extra: ToolInvocationContext):
    ...
```

ハンドラが第 2 の位置引数を受け取る場合、SDK は `ToolInvocationContext` を渡します。`extra.signal` は CLI が実行中のツール呼び出しをキャンセルしたときにセットされます。

<div id="toolannotations" />

#### `ToolAnnotations`

Python 版は `mcp.types.ToolAnnotations` を直接使用します。

```python theme={null}
from mcp.types import ToolAnnotations


ToolAnnotations(
    title="Search docs",
    readOnlyHint=True,
    destructiveHint=False,
    idempotentHint=True,
    openWorldHint=False,
    maxResultSizeChars=500_000,
)
```

| フィールド                | 型      | 省略可 | 意味                         | 現在の Qoder の挙動                                                                                           |
| -------------------- | ------ | --- | -------------------------- | ------------------------------------------------------------------------------------------------------- |
| `title`              | `str`  | はい  | ツールの人間可読タイトル               | MCP メタデータ。現状 Qoder で検証済みの挙動能力ではない                                                                       |
| `readOnlyHint`       | `bool` | はい  | ツールが状態を変更しないことを示す          | 観測可能な効果としては、読み取り専用ツールは同一バッチ内のツール呼び出しで並列実行の対象になる。権限スイッチではない                                              |
| `destructiveHint`    | `bool` | はい  | ツールが破壊的な更新を行う可能性を示す        | リスクメタデータ。現状、許可されたツール実行を自動でブロックしない                                                                       |
| `openWorldHint`      | `bool` | はい  | ツールが外部のオープンワールドと相互作用するかを示す | 外部対話メタデータ。現状、許可されたツール実行を自動でブロックしない                                                                      |
| `maxResultSizeChars` | `int`  | はい  | ツール結果サイズの上限を示す             | Python SDK は `_meta["anthropic/maxResultSizeChars"]` に書き込み、CLI が読み取る。これは Python で現在使用されている MCP 型拡張フィールド |

これらのフィールドはメタデータとスケジューリングヒントであり、権限スイッチではありません。実行可否は依然として `tools`、`allowed_tools`、`disallowed_tools`、`permission_mode`、`can_use_tool`、フックによって決まります。

<div id="create_sdk_mcp_server" />

### `create_sdk_mcp_server()`

SDK と同一プロセス内で動作する MCP サーバーを作成します。

```python theme={null}
from typing import Any


def create_sdk_mcp_server(
    name: str,
    version: str = "1.0.0",
    tools: list[SdkMcpTool[Any]] | None = None,
) -> McpSdkServerConfig:
    ...
```

| パラメータ     | デフォルト     | 説明                                              |
| --------- | --------- | ----------------------------------------------- |
| `name`    | 必須        | MCP サーバー名。`mcp__{serverName}__{toolName}` で使われる |
| `version` | `"1.0.0"` | サーバーのバージョン情報                                    |
| `tools`   | `None`    | このサーバーに登録するツールのリスト                              |

<div id="createsdkmcpserveroptions" />

#### `CreateSdkMcpServerOptions`

TypeScript SDK は `CreateSdkMcpServerOptions` というオブジェクトパラメータを使いますが、Python SDK はこの型をエクスポートしておらず、オプションオブジェクトも使いません。Python での同等物は `create_sdk_mcp_server(name, version="1.0.0", tools=None)` の 3 つの関数パラメータです。

<div id="create_sdk_mcp_server-return-value" />

<div id="createsdkmcpserver-return-value" />

#### Return Value

`QoderAgentOptions.mcp_servers` の値として直接利用できる `McpSdkServerConfig` を返します。

```python theme={null}
from typing import Literal, TypedDict

from typing_extensions import NotRequired


class McpSdkServerConfig(TypedDict):
    type: Literal["sdk"]
    name: str
    instance: McpServer
    tools: NotRequired[list[McpServerToolPolicy]]
```

#### `McpServerToolPolicy`

```python theme={null}
class McpServerToolPolicy(TypedDict):
    name: str
    permission_policy: Literal["always_allow", "always_ask", "always_deny"]
```

`tools` ポリシーフィールドは Python 型に存在します。主に MCP サーバー設定レイヤでのツール権限ポリシーに使われます。一般的なインプロセス SDK サーバー統合では、依然として `allowed_tools`、`disallowed_tools`、`permission_mode`、`can_use_tool`、フックを通じて制御します。

<div id="calltoolresult" />

### `CallToolResult`

Python SDK は独自の `CallToolResult` 型をエクスポートしていません。ハンドラは dict を返し、SDK がそれを MCP の `CallToolResult` に変換します。

```python theme={null}
from typing import Literal, TypedDict

from typing_extensions import NotRequired


class TextToolContent(TypedDict):
    type: Literal["text"]
    text: str


class ImageToolContent(TypedDict):
    type: Literal["image"]
    data: str
    mimeType: str


class ResourceLinkToolContent(TypedDict):
    type: Literal["resource_link"]
    uri: str
    name: NotRequired[str]
    description: NotRequired[str]
    mimeType: NotRequired[str]


class EmbeddedResourceValue(TypedDict, total=False):
    uri: str
    mimeType: str
    text: str
    blob: str


class EmbeddedResourceToolContent(TypedDict):
    type: Literal["resource"]
    resource: EmbeddedResourceValue


ToolContent = (
    TextToolContent
    | ImageToolContent
    | ResourceLinkToolContent
    | EmbeddedResourceToolContent
)


class ToolHandlerResult(TypedDict):
    content: list[ToolContent]
    is_error: NotRequired[bool]
```

<div id="mcptoolresultcontent" />

#### `McpToolResultContent`

Python SDK は現在、次のコンテンツブロックを認識します：

| 種類           | Python ハンドラ dict                                                               | 現在の Qoder の挙動                                              |
| ------------ | ------------------------------------------------------------------------------ | ---------------------------------------------------------- |
| テキスト         | `{"type": "text", "text": "..."}`                                              | `TextContent` に変換                                          |
| 画像           | `{"type": "image", "data": "...", "mimeType": "image/png"}`                    | `ImageContent` に変換                                         |
| リソースリンク      | `{"type": "resource_link", "uri": "...", "name": "...", "description": "..."}` | `TextContent` にダウングレードし、`name` / `uri` / `description` を連結 |
| 埋め込みテキストリソース | `{"type": "resource", "resource": {"text": "..."}}`                            | `TextContent` に変換                                          |
| 埋め込みバイナリリソース | `{"type": "resource", "resource": {"blob": "..."}}`                            | 現状はスキップされ、警告がログ出力される                                       |

TS リファレンスとの相違点：

* Python ハンドラは `is_error` を使い、MCP / TypeScript の `isError` というフィールド名ではない。SDK は内部で MCP の `isError` にマッピングする。
* Python ハンドラのトップレベル `_meta` は現状 `CallToolResult` に渡されない。
* Python の `call_tool` 変換ロジックは現状 `audio` コンテンツブロックを扱わない。MCP の型として `AudioContent` がインポートされていても、`{"type": "audio"}` を返すハンドラは未対応コンテンツの警告分岐に入る。

<div id="can_use_tool" />

### `can_use_tool`

ツール権限承認コールバックは共通型で定義されており、参照しやすさのためここに再掲します。

```python theme={null}
from collections.abc import Awaitable, Callable
from dataclasses import dataclass, field
from typing import Any, Literal


@dataclass
class ToolPermissionContext:
    signal: asyncio.Event | None = None
    suggestions: list[Any] = field(default_factory=list)
    blocked_path: str | None = None
    decision_reason: str | None = None
    decision_reason_type: str | None = None
    classifier_approvable: bool | None = None
    title: str | None = None
    display_name: str | None = None
    description: str | None = None
    tool_use_id: str | None = None
    agent_id: str | None = None
    exit_plan_mode: ExitPlanModeApprovalDetails | None = None


CanUseTool = Callable[
    [str, dict[str, Any], ToolPermissionContext],
    Awaitable[PermissionResult],
]
```

#### `PermissionResult`

```python theme={null}
@dataclass
class PermissionResultAllow:
    behavior: Literal["allow"] = "allow"
    updated_input: dict[str, Any] | None = None
    updated_permissions: list[PermissionUpdate | dict[str, Any]] | None = None
    decision_classification: PermissionDecisionClassification | None = None


@dataclass
class PermissionResultDeny:
    behavior: Literal["deny"] = "deny"
    message: str = ""
    interrupt: bool = False
    decision_classification: PermissionDecisionClassification | None = None


PermissionResult = PermissionResultAllow | PermissionResultDeny
```

`can_use_tool` が受け取る `tool_name` はフルツール名で、例えば `Bash`、`Read`、`mcp__orders__lookup_order` です。

<div id="mcp-status-tool-information" />

<div id="mcpstatustoolinformation" />

### MCP Status Tool Information

Python SDK は `McpToolInfo` と `McpToolAnnotations` をエクスポートし、`QoderSDKClient.get_mcp_status()` が返すサーバー単位のツール情報を表現します。

```python theme={null}
from typing import TypedDict

from typing_extensions import NotRequired


class McpToolAnnotations(TypedDict, total=False):
    readOnly: bool
    destructive: bool
    openWorld: bool


class McpToolInfo(TypedDict):
    name: str
    description: NotRequired[str]
    annotations: NotRequired[McpToolAnnotations]
```

注意: ステータス内の annotation フィールド名は CLI が射影した `readOnly`、`destructive`、`openWorld` であり、`ToolAnnotations` 入力の `readOnlyHint`、`destructiveHint`、`openWorldHint` ではありません。`idempotentHint` は現状ステータスのツール一覧にエコーされません。

<div id="built-in-tool-input-output-types" />

<div id="builtintoolinputoutputtypes" />

<div id="built-in-tool-inputoutput-types" />

<div id="built-in-tool-input-and-output-types" />

### Built-in Tool Input/Output Types

TypeScript SDK は組み込みツールの入力 / 出力構造を型レベルで提供しています。Python SDK は現状これらの TypedDict をエクスポートしておらず、`ToolInputSchemas` / `ToolOutputSchemas` のユニオン型もエクスポートしていません。注意: 下表の型名は TypeScript 参照型名であり、Python の権限設定とツール許可リストでは依然として[組み込みツール一覧](#built-in-tool-list)の実行時ツール名を使用します。

| TypeScript 型                                       | Python SDK の状況               |
| -------------------------------------------------- | ---------------------------- |
| `AgentInput` / `AgentOutput`                       | 未エクスポート                      |
| `BashInput` / `BashOutput`                         | 未エクスポート                      |
| `FileReadInput` / `FileReadOutput`                 | 未エクスポート。実行時ツール名は `Read` のまま  |
| `FileEditInput` / `FileEditOutput`                 | 未エクスポート。実行時ツール名は `Edit` のまま  |
| `FileWriteInput` / `FileWriteOutput`               | 未エクスポート。実行時ツール名は `Write` のまま |
| `GlobInput` / `GlobOutput`                         | 未エクスポート                      |
| `GrepInput` / `GrepOutput`                         | 未エクスポート                      |
| `WebFetchInput` / `WebFetchOutput`                 | 未エクスポート                      |
| `WebSearchInput` / `WebSearchOutput`               | 未エクスポート                      |
| `AskUserQuestionInput` / `AskUserQuestionOutput`   | 未エクスポート                      |
| `NotebookEditInput` / `NotebookEditOutput`         | 未エクスポート                      |
| `TaskOutputInput`                                  | 未エクスポート                      |
| `TaskStopInput` / `TaskStopOutput`                 | 未エクスポート                      |
| `ExitPlanModeInput` / `ExitPlanModeOutput`         | 未エクスポート                      |
| `ConfigInput` / `ConfigOutput`                     | 未エクスポート                      |
| `EnterWorktreeInput` / `EnterWorktreeOutput`       | 未エクスポート                      |
| `ExitWorktreeInput` / `ExitWorktreeOutput`         | 未エクスポート                      |
| `TodoWriteInput` / `TodoWriteOutput`               | 未エクスポート                      |
| `ListMcpResourcesInput` / `ListMcpResourcesOutput` | 未エクスポート                      |
| `ReadMcpResourceInput`                             | 未エクスポート                      |
| `McpInput` / `McpOutput`                           | 未エクスポート                      |
| `ToolInputSchemas`                                 | 未エクスポート                      |
| `ToolOutputSchemas`                                | 未エクスポート                      |

Python 側で安定して設定可能なものは[組み込みツール一覧](#built-in-tool-list)の実行時ツール名です。Python アプリケーションで組み込みツールパラメータの強い型付けが必要な場合は、ビジネス側で独自の `TypedDict` または dataclass を定義してください。

### Related Documentation

* [ツール利用ガイド](/ja/cli/sdk/python/tools)
* [MCP 統合](/ja/cli/sdk/python/mcp)
* [権限制御](/ja/cli/sdk/python/permissions)
* [フック](/ja/cli/sdk/python/hooks)
* [サブエージェント利用ガイド](/ja/cli/sdk/python/agents)

<div id="hooks-reference" />

<div id="hooksreference" />

## Hooks Reference

使い方ガイドと例については [Hooks](/ja/cli/sdk/python/hooks) を参照してください。

<div id="event-overview" />

<div id="eventoverview" />

### Event Overview

| イベント                 | トリガー               | 制御可能な動作                |
| -------------------- | ------------------ | ---------------------- |
| `PreToolUse`         | ツール呼び出しの前          | ブロック / 許可 / 入力の変更      |
| `PostToolUse`        | ツールが成功した後          | 監査 / コンテキスト注入 / 出力の上書き |
| `PostToolUseFailure` | ツールが失敗した後          | エラーハンドリング / ロギング       |
| `UserPromptSubmit`   | ユーザープロンプトが送信される前   | コンテキスト注入 / ブロック        |
| `SessionStart`       | セッション開始時           | 初期化 / コンテキスト注入         |
| `SessionEnd`         | セッション終了時           | クリーンアップ / ロギング         |
| `Stop`               | AI が生成を停止するとき      | 停止をブロックして強制継続          |
| `SubagentStart`      | サブエージェントが開始するとき    | 観測 / ログ                |
| `SubagentStop`       | サブエージェントが停止するとき    | 観測 / ログ                |
| `PreCompact`         | コンテキスト圧縮の前         | 観測 / ログ                |
| `PostCompact`        | コンテキスト圧縮の後         | 観測 / ログ                |
| `CwdChanged`         | 作業ディレクトリ変更時        | 観測 / ログ                |
| `InstructionsLoaded` | 指示ファイルがロードされたとき    | 観測 / ログ                |
| `FileChanged`        | ファイルが作成/変更/削除されたとき | 観測 / ログ                |
| `PermissionRequest`  | パーミッションが要求されたとき    | パーミッション要求の自動許可 / 拒否    |

<div id="hookevent" />

### `HookEvent`

登録可能な hook イベントの Union 型。

```python theme={null}
HookEvent = Literal[
    "PreToolUse",
    "PostToolUse",
    "PostToolUseFailure",
    "UserPromptSubmit",
    "SessionStart",
    "SessionEnd",
    "Stop",
    "SubagentStart",
    "SubagentStop",
    "PreCompact",
    "PostCompact",
    "CwdChanged",
    "InstructionsLoaded",
    "FileChanged",
    "PermissionRequest",
]
```

<div id="hookcallback" />

### `HookCallback`

```python theme={null}
HookCallback = Callable[
    [HookInput, str | None, HookCallbackOptions],
    Awaitable[HookJSONOutput],
]
```

<div id="hookmatcher" />

### `HookMatcher`

```python theme={null}
@dataclass
class HookMatcher:
    hooks: list[HookCallback]
    matcher: str | None = None
    timeout: int | None = None  # seconds, default 60
```

| フィールド     | 型                    | 説明                           |
| :-------- | :------------------- | :--------------------------- |
| `hooks`   | `list[HookCallback]` | マッチした際に実行されるコールバックのリスト       |
| `matcher` | `str \| None`        | 任意の正規表現。`tool_name` でフィルタリング |
| `timeout` | `int \| None`        | 任意のタイムアウト(秒)。デフォルト 60        |

<div id="basehookinput" />

### `BaseHookInput`

すべての hook イベントで共通の入力フィールド。

```python theme={null}
@dataclass
class BaseHookInput:
    hook_event_name: str
    session_id: str
    transcript_path: str
    cwd: str
```

| フィールド             | 型     | 説明                               |
| :---------------- | :---- | :------------------------------- |
| `hook_event_name` | `str` | イベントタイプの識別子(例: `"PreToolUse"`)   |
| `session_id`      | `str` | 現在のセッションの一意な識別子                  |
| `transcript_path` | `str` | セッションのトランスクリプトファイル(JSONL 形式)へのパス |
| `cwd`             | `str` | セッションの現在の作業ディレクトリ                |

<div id="hookjsonoutput" />

### `HookJSONOutput`

hook コールバックの戻り値の型。

```python theme={null}
@dataclass
class HookJSONOutput:
    continue_: bool | None = None       # JSON key is "continue"
    stop_reason: str | None = None      # JSON key is "stopReason"
    decision: str | None = None
    reason: str | None = None
    hook_specific_output: dict | None = None  # JSON key is "hookSpecificOutput"
```

| フィールド                  | 型              | デフォルト              | 説明                                                                                                                      |
| :--------------------- | :------------- | :----------------- | :---------------------------------------------------------------------------------------------------------------------- |
| `continue_`            | `bool \| None` | `None`(`True` と等価) | `False` を設定するとセッションを終了する。`PreToolUse`、`PostToolUse`、`PostToolUseFailure`、`UserPromptSubmit`、`Stop`、`SubagentStop` でのみ有効 |
| `stop_reason`          | `str \| None`  | `None`             | セッションを停止する理由(人間可読)。`continue_=False` と組み合わせて使う                                                                          |
| `decision`             | `str \| None`  | `None`             | `"approve"` または `"block"`。`"block"` はツール実行をブロックする。`Stop` イベントでは `"block"` は停止をブロックして強制継続する                              |
| `reason`               | `str \| None`  | `None`             | 判断の理由(モデルに表示される。`Stop` イベントの `"block"` 判断では、継続プロンプトとしてコンテキストに注入される)                                                     |
| `hook_specific_output` | `dict \| None` | `None`             | イベント固有の出力(各イベント型を参照)                                                                                                    |

> Python SDK では `continue_` は JSON キー `"continue"` に対応します(キーワード衝突回避のため)。
> 複数の hook が競合する `decision` を返した場合、`"deny"` / `"block"` が優先されます(最も厳しいルールが勝つ)。

<div id="pretoolusehookinput" />

### `PreToolUseHookInput`

```python theme={null}
@dataclass
class PreToolUseHookInput(BaseHookInput):
    hook_event_name: Literal["PreToolUse"]
    permission_mode: str | None
    tool_name: str
    tool_input: Any
```

| フィールド             | 型             | 説明                  |
| :---------------- | :------------ | :------------------ |
| `permission_mode` | `str \| None` | セッションの現在のパーミッションモード |
| `tool_name`       | `str`         | 呼び出されるツールの名前        |
| `tool_input`      | `Any`         | ツールに渡されるパラメータ       |

**`hook_specific_output` (`hookSpecificOutput`):**

| フィールド                      | 型              | 説明                                         |
| :------------------------- | :------------- | :----------------------------------------- |
| `hookEventName`            | `"PreToolUse"` | 必ず設定する                                     |
| `permissionDecision`       | `str`          | `"allow"` / `"deny"` / `"ask"` / `"defer"` |
| `permissionDecisionReason` | `str`          | パーミッション判断の理由                               |
| `updatedInput`             | `dict`         | 元の `tool_input` を置き換える変更済みのツール入力           |
| `additionalContext`        | `str`          | モデルの次のターンに注入される追加コンテキスト                    |

<div id="posttoolusehookinput" />

### `PostToolUseHookInput`

```python theme={null}
@dataclass
class PostToolUseHookInput(BaseHookInput):
    hook_event_name: Literal["PostToolUse"]
    tool_name: str
    tool_input: Any
    tool_response: Any
```

| フィールド           | 型     | 説明            |
| :-------------- | :---- | :------------ |
| `tool_name`     | `str` | 呼び出されたツールの名前  |
| `tool_input`    | `Any` | ツールに渡されたパラメータ |
| `tool_response` | `Any` | ツール実行の結果      |

**出力動作:**

| フィールド                                  | 場所       | 動作                                          |
| :------------------------------------- | :------- | :------------------------------------------ |
| `hookSpecificOutput.updatedToolOutput` | イベント固有出力 | `tool_response` を **上書き**。モデルには上書き後の値のみが見える |
| `hookSpecificOutput.additionalContext` | イベント固有出力 | 元の結果を変更せずに補足コンテキストを **追加**                  |
| `decision: "block"` + `reason`         | トップレベル出力 | エージェントがツール結果をさらに処理することを防ぐ                   |

**`hook_specific_output` (`hookSpecificOutput`):**

| フィールド               | 型               | 説明                     |
| :------------------ | :-------------- | :--------------------- |
| `hookEventName`     | `"PostToolUse"` | 必ず設定する                 |
| `updatedToolOutput` | `str`           | ツールのレスポンス内容を上書きする      |
| `additionalContext` | `str`           | ツール結果と一緒に追加される追加コンテキスト |

> 複数の hook が `updatedToolOutput` を設定した場合、**最後の空でない値** が勝ちます。連鎖的な変換を行う場合は、1 つのコールバック内で順次処理してください。

<div id="posttoolusefailurehookinput" />

### `PostToolUseFailureHookInput`

```python theme={null}
@dataclass
class PostToolUseFailureHookInput(BaseHookInput):
    hook_event_name: Literal["PostToolUseFailure"]
    tool_name: str
    tool_input: Any
    error: str
    is_interrupt: bool | None
```

| フィールド          | 型              | 説明                 |
| :------------- | :------------- | :----------------- |
| `tool_name`    | `str`          | 失敗したツールの名前         |
| `tool_input`   | `Any`          | ツールに渡されたパラメータ      |
| `error`        | `str`          | エラーメッセージ           |
| `is_interrupt` | `bool \| None` | 中断 / アボートによるものかどうか |

<div id="userpromptsubmithookinput" />

### `UserPromptSubmitHookInput`

```python theme={null}
@dataclass
class UserPromptSubmitHookInput(BaseHookInput):
    hook_event_name: Literal["UserPromptSubmit"]
    prompt: str
```

| フィールド    | 型     | 説明            |
| :------- | :---- | :------------ |
| `prompt` | `str` | ユーザーが入力したテキスト |

**`hook_specific_output` (`hookSpecificOutput`):**

| フィールド               | 型                    | 説明                    |
| :------------------ | :------------------- | :-------------------- |
| `hookEventName`     | `"UserPromptSubmit"` | 必ず設定する                |
| `additionalContext` | `str`                | ユーザープロンプトに追加されるコンテキスト |

<div id="sessionstarthookinput" />

### `SessionStartHookInput`

```python theme={null}
@dataclass
class SessionStartHookInput(BaseHookInput):
    hook_event_name: Literal["SessionStart"]
    source: str
```

| フィールド    | 型     | 説明                                                             |
| :------- | :---- | :------------------------------------------------------------- |
| `source` | `str` | セッション開始の理由: `"startup"` / `"resume"` / `"clear"` / `"compact"` |

**`hook_specific_output` (`hookSpecificOutput`):**

| フィールド               | 型                | 説明                   |
| :------------------ | :--------------- | :------------------- |
| `hookEventName`     | `"SessionStart"` | 必ず設定する               |
| `additionalContext` | `str`            | セッション開始時に注入されるコンテキスト |

<div id="sessionendhookinput" />

### `SessionEndHookInput`

```python theme={null}
@dataclass
class SessionEndHookInput(BaseHookInput):
    hook_event_name: Literal["SessionEnd"]
    reason: str
```

| フィールド    | 型     | 説明                                                                                                                    |
| :------- | :---- | :-------------------------------------------------------------------------------------------------------------------- |
| `reason` | `str` | セッション終了の理由: `"clear"` / `"resume"` / `"logout"` / `"prompt_input_exit"` / `"other"` / `"bypass_permissions_disabled"` |

<div id="stophookinput" />

### `StopHookInput`

```python theme={null}
@dataclass
class StopHookInput(BaseHookInput):
    hook_event_name: Literal["Stop"]
    stop_hook_active: bool
```

| フィールド              | 型      | 説明                            |
| :----------------- | :----- | :---------------------------- |
| `stop_hook_active` | `bool` | 現在 Stop hook が停止をブロックしているかどうか |

`{"decision": "block", "reason": "..."}` を返すと、AI の停止をブロックして強制継続させます。`reason` は継続プロンプトとしてモデルのコンテキストに注入されます。

<div id="subagentstarthookinput" />

### `SubagentStartHookInput`

```python theme={null}
@dataclass
class SubagentStartHookInput(BaseHookInput):
    hook_event_name: Literal["SubagentStart"]
    agent_id: str
    agent_type: str
```

| フィールド        | 型     | 説明                    |
| :----------- | :---- | :-------------------- |
| `agent_id`   | `str` | サブエージェントインスタンスの一意な識別子 |
| `agent_type` | `str` | サブエージェントの種別 / 役割      |

<div id="subagentstophookinput" />

### `SubagentStopHookInput`

```python theme={null}
@dataclass
class SubagentStopHookInput(BaseHookInput):
    hook_event_name: Literal["SubagentStop"]
    stop_hook_active: bool
```

| フィールド              | 型      | 説明                            |
| :----------------- | :----- | :---------------------------- |
| `stop_hook_active` | `bool` | 現在 Stop hook が停止をブロックしているかどうか |

<div id="precompacthookinput" />

### `PreCompactHookInput`

```python theme={null}
@dataclass
class PreCompactHookInput(BaseHookInput):
    hook_event_name: Literal["PreCompact"]
    trigger: str
    custom_instructions: str | None
```

| フィールド                 | 型             | 説明                            |
| :-------------------- | :------------ | :---------------------------- |
| `trigger`             | `str`         | トリガー理由: `"manual"` / `"auto"` |
| `custom_instructions` | `str \| None` | 圧縮サマリーに対するカスタム指示              |

<div id="postcompacthookinput" />

### `PostCompactHookInput`

```python theme={null}
@dataclass
class PostCompactHookInput(BaseHookInput):
    hook_event_name: Literal["PostCompact"]
    trigger: str
    compact_summary: str
```

| フィールド             | 型     | 説明                            |
| :---------------- | :---- | :---------------------------- |
| `trigger`         | `str` | トリガー理由: `"manual"` / `"auto"` |
| `compact_summary` | `str` | コンテキスト圧縮後に生成されたサマリー           |

<div id="cwdchangedhookinput" />

### `CwdChangedHookInput`

```python theme={null}
@dataclass
class CwdChangedHookInput(BaseHookInput):
    hook_event_name: Literal["CwdChanged"]
    old_cwd: str
    new_cwd: str
```

| フィールド     | 型     | 説明           |
| :-------- | :---- | :----------- |
| `old_cwd` | `str` | 変更前の作業ディレクトリ |
| `new_cwd` | `str` | 変更後の作業ディレクトリ |

<div id="instructionsloadedhookinput" />

### `InstructionsLoadedHookInput`

```python theme={null}
@dataclass
class InstructionsLoadedHookInput(BaseHookInput):
    hook_event_name: Literal["InstructionsLoaded"]
    load_reason: str
```

| フィールド         | 型     | 説明                                                |
| :------------ | :---- | :------------------------------------------------ |
| `load_reason` | `str` | ロード理由: `"nested_traversal"` / `"path_glob_match"` |

<div id="filechangedhookinput" />

### `FileChangedHookInput`

```python theme={null}
@dataclass
class FileChangedHookInput(BaseHookInput):
    hook_event_name: Literal["FileChanged"]
    file_path: str
    event: str
```

| フィールド       | 型     | 説明                                              |
| :---------- | :---- | :---------------------------------------------- |
| `file_path` | `str` | 変更されたファイルのパス                                    |
| `event`     | `str` | ファイルシステムイベント: `"change"` / `"add"` / `"unlink"` |

<div id="permissionrequesthookinput" />

### `PermissionRequestHookInput`

```python theme={null}
@dataclass
class PermissionRequestHookInput(BaseHookInput):
    hook_event_name: Literal["PermissionRequest"]
    tool_name: str
    tool_input: Any
    permission_suggestions: list | None
```

| フィールド                    | 型              | 説明                |
| :----------------------- | :------------- | :---------------- |
| `tool_name`              | `str`          | パーミッションを要求しているツール |
| `tool_input`             | `Any`          | ツール入力パラメータ        |
| `permission_suggestions` | `list \| None` | 推奨されるパーミッションルール   |

**`hook_specific_output` (`hookSpecificOutput`):**

| フィールド           | 型                     | 説明              |
| :-------------- | :-------------------- | :-------------- |
| `hookEventName` | `"PermissionRequest"` | 必ず設定する          |
| `decision`      | `dict`                | パーミッション判断(下記参照) |

`decision` は次のいずれかです:

* **承認:** `{"behavior": "allow", "updatedInput": {...}, "updatedPermissions": [...]}`
* **拒否:** `{"behavior": "deny", "message": "..."}`

<div id="message-types" />

<div id="messagetypes" />

## Message Types

<div id="assistantmessage" />

### `AssistantMessage`

AI の完全な応答で、ターンごとに 1 回配信されます。`content` は `TextBlock` と `ToolUseBlock` のリストです。

```python theme={null}
@dataclass
class AssistantMessage:
    content: list[TextBlock | ToolUseBlock]
    parent_tool_use_id: str | None = None
    session_id: str | None = None
    uuid: str | None = None
```

<div id="resultmessage" />

### `ResultMessage`

セッション全体の終了時に送られる最終メッセージです。

```python theme={null}
@dataclass
class ResultMessage:
    subtype: str  # "success" | "error_max_turns" | "error_during_execution" | ...
    duration_ms: int
    num_turns: int
    session_id: str
    total_cost_usd: float | None = None
    result: str | None = None  # only present when subtype == "success"
```

<div id="systemmessage" />

### `SystemMessage`

セッションのシステムメッセージです。`subtype == "init"` の場合、`data` に初期化情報（session\_id、model、tools など）が含まれます。

```python theme={null}
@dataclass
class SystemMessage:
    subtype: str  # "init" | "compact_boundary" | "status" | "mcp_status_change" | ...
    data: dict[str, Any]
```

<div id="streamevent" />

### `StreamEvent`

`include_partial_messages=True` が必要です。トークン単位でストリーミングされます。

```python theme={null}
@dataclass
class StreamEvent:
    uuid: str
    session_id: str
    event: dict[str, Any]  # upstream-compatible raw stream event
    parent_tool_use_id: str | None = None
```

`event["type"]` の値:

| `event["type"]`       | 説明                                                       |
| :-------------------- | :------------------------------------------------------- |
| `message_start`       | メッセージ開始                                                  |
| `content_block_start` | ブロック開始（text / tool\_use / thinking）                      |
| `content_block_delta` | 増分: `text_delta` / `input_json_delta` / `thinking_delta` |
| `content_block_stop`  | ブロック終了                                                   |
| `message_delta`       | メッセージレベルの状態変化（例: stop\_reason）                           |
| `message_stop`        | 完全なターンの終了                                                |

詳しい使い方は [ストリーミング出力](/ja/cli/sdk/python/streaming-output) を参照してください。

<div id="content-blocks" />

<div id="contentblocks" />

### Content Blocks

`AssistantMessage.content` の要素:

```python theme={null}
@dataclass
class TextBlock:
    text: str


@dataclass
class ToolUseBlock:
    id: str
    name: str
    input: dict[str, Any]
```
