OpenAI互換プロトコル

OpenAI互換プロトコルは、業界で最も広くサポートされているAI APIの標準規格です。RouteAPIはOpenAI APIの仕様を完全に実装しており、Base URLとAPI Keyを切り替えるだけで、既存のOpenAI SDK、ツール、クライアントとシームレスに統合できます。

プロトコル概要

OpenAI APIは、会話生成、テキスト埋め込み、モデル一覧など、標準化されたREST インターフェースのセットを定義しています。その主な利点は、成熟したエコシステムにあります。OpenAI公式SDK、LangChain、LiteLLM、Cursor、各種コーディングアシスタントがこのプロトコルをネイティブにサポートしています。

RouteAPIの互換範囲:

OpenAI Chat Completions、Responses、Embeddings、Modelsエンドポイントと完全互換
Authorization: Bearerリクエストヘッダーを使用した統一認証
ストリーミングSSEとエラー構造を含む統一リクエスト/レスポンス形式
より広範なモデルID範囲、OpenAI、Claude、Gemini、Mistralなどのプロバイダーを呼び出し可能
明示的なゼロ値パラメータの保持、明示的に渡された0/falseは削除されません

公式OpenAI APIからRouteAPIへの移行には、2つの設定変更のみが必要です:

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-routeapi-token",        # RouteAPI Tokenに切り替え
    base_url="https://api.routeapi.ai/v1"   # RouteAPI Base URLに切り替え
)

その他のコードはすべて変更不要です。

Base URL

https://api.routeapi.ai/v1

すべてのOpenAI互換エンドポイントは、このBase URLを使用します。クライアントまたはSDKが完全なURLを必要とする場合は、エンドポイントパスを追加するだけです。例: https://api.routeapi.ai/v1/chat/completions

認証

公式OpenAI APIと同様に、HTTP Authorizationリクエストヘッダーを使用します:

Authorization: Bearer sk-your-routeapi-token
Content-Type: application/json

RouteAPI Tokenはsk-で始まり、コンソールのAPIキーページで生成されます。トークンはサーバーサイドで保存し、ブラウザ、モバイルアプリ、パブリックリポジトリには公開しないでください。

サポートされるエンドポイント概要

エンドポイント	用途	詳細ドキュメント
`/v1/chat/completions`	会話生成、マルチターン対話、ツール呼び出し、構造化出力をサポート	Chat Completions
`/v1/responses`	OpenAI Responsesプロトコル、コーディングエージェントと次世代アプリケーションフレームワークに適しています	Responses
`/v1/embeddings`	テキストベクトル埋め込み、セマンティック検索、RAG、類似度計算用	Embeddings
`/v1/models`	現在のアカウントで利用可能なモデルリストを取得	このページの下部

ユースケース比較

シナリオ	推奨エンドポイント	理由
一般的なチャット、Q&A、要約、分類	`/v1/chat/completions`	最も成熟したエコシステム、最も広い互換性
コーディングエージェント（Cursor、Claude Code、Copilot）	`/v1/responses`または`/v1/chat/completions`	クライアントがネイティブにサポートするプロトコルに依存
マルチターン対話、会話履歴	`/v1/chat/completions`	`messages`配列が複数のラウンドを自然にサポート
ツール呼び出し、関数呼び出し	`/v1/chat/completions`	最も標準的なツール定義と結果渡し構造
セマンティック検索、RAG、ドキュメント検索	`/v1/embeddings`	ベクトル表現を返します
構造化出力、JSON Schema	`/v1/chat/completions`または`/v1/responses`	`response_format`パラメータで制御

具体的なエンドポイントの選択は、クライアントとSDKのネイティブサポートを優先すべきです。クライアントが特定のプロトコルを明示的に要求する場合は、クライアントの要件に従ってください。

SDK設定

OpenAI Python SDK

インストール:

pip install openai

RouteAPIを設定:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ROUTEAPI_KEY"],
    base_url="https://api.routeapi.ai/v1"
)

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "user", "content": "RouteAPIを一文で紹介してください"}
    ]
)

print(response.choices[0].message.content)

api_keyとbase_urlパラメータのみを設定する必要があり、その他のコードは公式APIと同一です。

OpenAI Node.js SDK

インストール:

npm install openai

RouteAPIを設定:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.ROUTEAPI_KEY,
  baseURL: 'https://api.routeapi.ai/v1'
});

const response = await client.chat.completions.create({
  model: 'gpt-5.5',
  messages: [
    { role: 'user', content: 'RouteAPIを一文で紹介してください' }
  ]
});

console.log(response.choices[0].message.content);

LangChain

LangChainのChatOpenAIクラスはカスタムbase_urlをサポートしています:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-5.5",
    openai_api_key=os.environ["ROUTEAPI_KEY"],
    openai_api_base="https://api.routeapi.ai/v1"
)

response = llm.invoke("RouteAPIを一文で紹介してください")
print(response.content)

LiteLLM

LiteLLMのcompletion()関数はカスタムapi_baseをサポートしています:

import litellm

response = litellm.completion(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "RouteAPIを一文で紹介してください"}],
    api_key=os.environ["ROUTEAPI_KEY"],
    api_base="https://api.routeapi.ai/v1"
)

print(response.choices[0].message.content)

その他の互換クライアント

OpenAI APIをサポートする任意のクライアント、ツール、またはフレームワークは、以下の設定でRouteAPIと統合できます:

API KeyをRouteAPI Token（sk-で始まる）に設定
Base URLをhttps://api.routeapi.ai/v1に設定
Model IDにRouteAPIがサポートするモデル名を使用（/v1/modelsで照会）

コアリクエストパラメータ

OpenAI互換プロトコルの主要エンドポイントは、コアパラメータセットを共有しています。以下は一般的なパラメータのクイックリファレンステーブルです。詳細な説明は各エンドポイントの専用ドキュメントをご覧ください。

Chat Completionsパラメータ

パラメータ	型	必須	説明
`model`	string	はい	モデルID、現在のアカウントで利用可能である必要があります
`messages`	array	はい	会話メッセージリスト、各メッセージには`role`と`content`が含まれます
`stream`	boolean	いいえ	SSEストリーミング出力を使用するか、デフォルトは`false`
`temperature`	number	いいえ	サンプリング温度、範囲は`0`から`2`、デフォルトは`1`
`top_p`	number	いいえ	Nucleusサンプリングパラメータ、範囲は`0`から`1`
`max_tokens`	number	いいえ	最大出力トークン数（レガシーパラメータ名、一部のモデルでは依然として必要）
`max_completion_tokens`	number	いいえ	最大出力トークン数（新しいパラメータ名）
`tools`	array	いいえ	関数呼び出し用のツール定義リスト
`tool_choice`	string/object	いいえ	ツール選択戦略（`auto`/`required`/`none`/特定のツール）
`response_format`	object	いいえ	出力フォーマット制約（JSONモード/JSON Schema）
`stream_options`	object	いいえ	追加のストリーミングオプション、例えば`include_usage`
`stop`	string/array	いいえ	カスタム停止シーケンス
`presence_penalty`	number	いいえ	プレゼンスペナルティ、範囲は`-2`から`2`
`frequency_penalty`	number	いいえ	頻度ペナルティ、範囲は`-2`から`2`
`user`	string	いいえ	不正使用検出用のエンドユーザー識別子

詳細な説明とその他のパラメータについては、Chat Completionsドキュメントをご参照ください。

Embeddingsパラメータ

パラメータ	型	必須	説明
`model`	string	はい	埋め込みモデルID
`input`	string/array	はい	埋め込むテキスト、単一の文字列または文字列配列をサポート
`encoding_format`	string	いいえ	返却フォーマット、`float`（デフォルト）または`base64`
`dimensions`	number	いいえ	出力ベクトル次元数、モデルのサポートに依存
`user`	string	いいえ	エンドユーザー識別子

詳細な説明については、Embeddingsドキュメントをご参照ください。

レスポンスフォーマット

標準レスポンス（非ストリーミング）

Chat Completions標準レスポンスの例:

{
  "id": "chatcmpl_xxx",
  "object": "chat.completion",
  "created": 1730000000,
  "model": "gpt-5.5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "RouteAPIは、複数のAIモデルプロバイダーへのアクセスを統合するAPIゲートウェイです。"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 24,
    "completion_tokens": 18,
    "total_tokens": 42
  }
}

主要フィールド:

choices[0].message.content — モデルのテキストレスポンス
choices[0].finish_reason — 完了理由（stop/length/tool_calls/content_filter）
usage — トークン使用統計

ストリーミングレスポンス（SSE）

stream: trueを設定すると、Server-Sent Events（SSE）フォーマットの増分データが返されます:

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"content":"RouteAPI"},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{"content":"は"},"finish_reason":null}]}

data: {"id":"chatcmpl_xxx","object":"chat.completion.chunk","created":1730000000,"model":"gpt-5.5","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":24,"completion_tokens":18,"total_tokens":42}}

data: [DONE]

ストリーミングレスポンスの特徴:

各行はdata: で始まり、その後にJSONオブジェクトが続きます
増分コンテンツはchoices[0].delta.contentにあります
完了時、finish_reasonがnullでなくなります
最後の行はdata: [DONE]です

ストリーミングモードでトークン使用統計が必要な場合は、stream_options: { "include_usage": true }を設定すると、最後のデータチャンクで使用情報が返されます。

エラーレスポンス

エラーレスポンスはOpenAIの標準フォーマットに従います:

{
  "error": {
    "message": "Invalid API key provided",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}

一般的なエラータイプ:

HTTPステータスコード	type	説明
401	`invalid_request_error`	無効または欠落しているAPI Key
429	`rate_limit_error`	レート制限超過
500	`api_error`	内部サーバーエラー
503	`overloaded_error`	サービス過負荷

詳細なエラー処理については、エラー処理ドキュメントをご参照ください。

公式OpenAI APIとの違い

RouteAPIのOpenAI互換プロトコルはプロトコルレベルで完全に互換性がありますが、モデル機能、課金、レート制限にいくつかの違いがあります:

より広範なモデルID範囲

公式OpenAI APIはOpenAI独自のモデル（gpt-4o、gpt-5.5など）のみを呼び出すことができます。RouteAPIは複数のプロバイダーのモデルをサポートします:

OpenAI: gpt-4o、gpt-5.5、o3-miniなど
Anthropic Claude: claude-sonnet-4-5、claude-opus-4など
Google Gemini: gemini-2.0-flash、gemini-2.5-proなど
Mistral: mistral-large、mistral-smallなど
その他: DeepSeek、Qwen、LLaMAなど

現在のアカウントで利用可能なモデルの完全なリストは、/v1/modelsエンドポイントで照会できます。

課金とレート制限はRouteAPIが管理

課金: RouteAPIのレートカードに従って課金され、上流プロバイダーの公式価格とは異なる場合があります
レート制限: RouteAPIのレート制限ポリシーによって制御され、上流プロバイダーの制限ではありません
クォータ: アカウント残高とクォータはRouteAPIが管理し、コンソールでチャージと確認が可能です

パラメータサポートは基盤モデルに依存

OpenAI互換プロトコルは完全なパラメータセットを定義していますが、実際のサポートは選択したモデルに依存します:

機能	説明
ツール呼び出し（`tools`）	モデルが関数呼び出しをサポートしているかに依存
構造化出力（`response_format`）	モデルがJSONモードまたはJSON Schemaをサポートしているかに依存
ビジュアル入力（`image_url`）	モデルがマルチモーダル入力をサポートしているかに依存
ストリーミング使用統計（`stream_options.include_usage`）	モデルとチャネルがストリーミング使用統計をサポートしているかに依存
推論制御（`reasoning_effort`）	一部の推論モデルのみがサポート

本番環境で有効にする前に、テスト環境で選択したモデルの主要パラメータのサポートを検証することをお勧めします。

明示的なゼロ値パラメータの処理

これは微妙ですが重要な違いです。OpenAI互換プロトコルでは、オプションパラメータが明示的に0、0.0、またはfalseとして渡された場合、RouteAPIはそれらをユーザーの明示的な設定として扱い、デフォルト値として削除しません。

例えば:

{
  "model": "gpt-5.5",
  "messages": [...],
  "temperature": 0,
  "top_p": 1.0
}

ここで、temperature: 0は保持され、上流モデルに転送されます。「値が0だから」未設定として扱われることはありません。これにより、クライアントがサンプリングパラメータを正確に制御できます。

特定のパラメータを渡したくない場合は、リクエストからそのフィールドを削除してください。nullや0を渡さないでください。

互換性に関する注意事項

機能は選択したモデルに依存

OpenAI互換プロトコルは標準インターフェース定義ですが、特定の機能は基盤モデルに依存します:

ツール呼び出し: モデルが関数呼び出しをサポートし、ツール定義フォーマットがモデル要件に一致する必要があります
構造化出力: モデルがJSONモードまたはJSON Schemaをサポートする必要があります
ビジュアル入力: モデルが画像またはマルチモーダル入力をサポートする必要があります
ストリーミング使用統計: モデルとチャネルがストリーミングモードでトークン使用を返すことをサポートする必要があります

リクエストにモデルがサポートしていないパラメータが含まれている場合、動作はパラメータタイプに依存します:

無視可能なパラメータ（frequency_penaltyなど）は黙って無視されます
重要なパラメータ（toolsなど）はエラーをトリガーする可能性があります

本番環境では、モデルIDを固定し、重要なビジネスフローのフォールバック戦略を準備することをお勧めします。

パラメータ検証とエラーメッセージ

RouteAPIはリクエストパラメータに対して基本的な検証を実行します:

必須パラメータの欠落（model、messagesなど）
誤ったパラメータタイプ（temperatureに文字列を渡すなど）
パラメータ値が範囲外（temperature: 3など）

検証が失敗すると、詳細なエラー情報とともに400 Bad Requestが返されます。リクエストがRouteAPIの検証を通過したが上流モデルに拒否された場合、上流の元のエラーメッセージとともに500または502が返されます。

クロスモデル移行の考慮事項

あるモデルから別のモデルに切り替える際、両方がOpenAI互換プロトコルを使用している場合でも、以下の点に注意する必要があります:

コンテキスト長: 異なるモデルには異なる最大コンテキスト長があります。長すぎるリクエストは拒否される可能性があります
ツール呼び出しフォーマット: 一部のモデルはツール記述フォーマットに対してより厳格な要件があります
出力スタイル: 同じプロンプトでも、異なるモデルで異なる出力スタイル、長さ、フォーマットが生成される可能性があります
トークンカウント: 異なるモデルには異なるトークナイザーがあります。同じテキストで異なるトークン数になる可能性があります
課金価格: 異なるモデルには異なる単価があります。モデルを切り替えるとコストに影響する可能性があります

本番環境でモデルを切り替える前に、テスト環境で完全なワークフローを検証することをお勧めします。

/v1/modelsエンドポイント

/v1/modelsエンドポイントは、現在のアカウントで利用可能なモデルのリストを、公式OpenAI APIと一致するフォーマットで返します。

リクエスト例

curl https://api.routeapi.ai/v1/models \
  -H "Authorization: Bearer $ROUTEAPI_KEY"

レスポンス例

{
  "success": true,
  "object": "list",
  "data": [
    {
      "id": "gpt-5.5",
      "object": "model",
      "created": 1626777600,
      "owned_by": "openai",
      "supported_endpoint_types": ["openai", "openai-response"]
    },
    {
      "id": "claude-sonnet-4-5",
      "object": "model",
      "created": 1626777600,
      "owned_by": "anthropic",
      "supported_endpoint_types": ["openai", "anthropic"]
    }
  ]
}

返されるdata配列は現在の Token で利用可能なモデルであり、プラットフォームの全量カタログではありません。各モデルオブジェクトには以下が含まれます:

id — モデルID、リクエスト時にこの値を使用します
object — "model"で固定
owned_by — モデルが属するチャネルタイプ。プラットフォームのカスタムモデルは custom
supported_endpoint_types — RouteAPI の拡張フィールド。そのモデルで利用可能なエンドポイントタイプ
created — 固定のプレースホルダー値 1626777600 であり、実際の公開時刻ではありません。ソートに使用しないでください

トップレベルに追加されるsuccessフィールドは RouteAPI の拡張です。OpenAI SDK はdataのみを読み取るため、解析に影響しません。dataの順序は安定性が保証されません。

アプリケーション起動時に一度/v1/modelsを呼び出し、利用可能なモデルリストをキャッシュし、リクエストごとに照会することを避けることをお勧めします。フィールドの意味とフィルタリングルールの詳細は Models を参照してください。

完全な例

curl基本会話

curl https://api.routeapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $ROUTEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [
      {
        "role": "system",
        "content": "あなたは厳密な技術アシスタントです。回答は簡潔に保ってください。"
      },
      {
        "role": "user",
        "content": "RouteAPIを一文で紹介してください"
      }
    ],
    "temperature": 0.7
  }'

Python SDK完全な例

import os
from openai import OpenAI

# クライアントを初期化
client = OpenAI(
    api_key=os.environ["ROUTEAPI_KEY"],
    base_url="https://api.routeapi.ai/v1"
)

# 基本会話
def basic_chat():
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "system", "content": "あなたは厳密な技術アシスタントです。"},
            {"role": "user", "content": "RouteAPIを一文で紹介してください"}
        ],
        temperature=0.7
    )
    print(response.choices[0].message.content)
    print(f"使用量: {response.usage.total_tokens} トークン")

# ストリーミング会話
def streaming_chat():
    stream = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "user", "content": "APIゲートウェイとは何か、段階的に説明してください"}
        ],
        stream=True,
        stream_options={"include_usage": True}
    )

    for chunk in stream:
        if chunk.choices:
            delta = chunk.choices[0].delta
            if delta.content:
                print(delta.content, end="", flush=True)
        # 最後のチャンクには使用量が含まれます
        if hasattr(chunk, 'usage') and chunk.usage:
            print(f"\n使用量: {chunk.usage.total_tokens} トークン")

# ツール呼び出し
def tool_calling():
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "指定された都市の現在の天気を照会します",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "都市名、例: 東京"
                        },
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["city"]
                }
            }
        }
    ]

    messages = [{"role": "user", "content": "今の東京の天気はどうですか?"}]

    # 第1ラウンド: モデルがツール呼び出しをリクエスト
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )

    # ツール呼び出しを確認
    if response.choices[0].message.tool_calls:
        # ツール実行をシミュレート
        tool_call = response.choices[0].message.tool_calls[0]
        tool_result = "東京、晴れ、気温23度、湿度45%。"

        # 第2ラウンドリクエストを構築
        messages.append(response.choices[0].message)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": tool_result
        })

        # 第2ラウンド: モデルがツール結果に基づいてレスポンスを生成
        final_response = client.chat.completions.create(
            model="gpt-5.5",
            messages=messages,
            tools=tools
        )
        print(final_response.choices[0].message.content)

# 構造化出力
def structured_output():
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "user", "content": "次のテキストから重要な情報を抽出してください: RouteAPIは、OpenAI、Claude、Geminiなどのモデルをサポートする AI APIゲートウェイです。"}
        ],
        response_format={
            "type": "json_schema",
            "json_schema": {
                "name": "key_info",
                "strict": True,
                "schema": {
                    "type": "object",
                    "properties": {
                        "product_name": {"type": "string"},
                        "category": {"type": "string"},
                        "supported_models": {
                            "type": "array",
                            "items": {"type": "string"}
                        }
                    },
                    "required": ["product_name", "category", "supported_models"],
                    "additionalProperties": False
                }
            }
        }
    )
    print(response.choices[0].message.content)

if __name__ == "__main__":
    basic_chat()
    print("\n" + "="*50 + "\n")
    streaming_chat()
    print("\n" + "="*50 + "\n")
    tool_calling()
    print("\n" + "="*50 + "\n")
    structured_output()

Node.js SDK完全な例

import OpenAI from 'openai';

// クライアントを初期化
const client = new OpenAI({
  apiKey: process.env.ROUTEAPI_KEY,
  baseURL: 'https://api.routeapi.ai/v1'
});

// 基本会話
async function basicChat() {
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'system', content: 'あなたは厳密な技術アシスタントです。' },
      { role: 'user', content: 'RouteAPIを一文で紹介してください' }
    ],
    temperature: 0.7
  });

  console.log(response.choices[0].message.content);
  console.log(`使用量: ${response.usage.total_tokens} トークン`);
}

// ストリーミング会話
async function streamingChat() {
  const stream = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      { role: 'user', content: 'APIゲートウェイとは何か、段階的に説明してください' }
    ],
    stream: true,
    stream_options: { include_usage: true }
  });

  for await (const chunk of stream) {
    if (chunk.choices[0]?.delta?.content) {
      process.stdout.write(chunk.choices[0].delta.content);
    }
    if (chunk.usage) {
      console.log(`\n使用量: ${chunk.usage.total_tokens} トークン`);
    }
  }
}

// ツール呼び出し
async function toolCalling() {
  const tools = [
    {
      type: 'function',
      function: {
        name: 'get_weather',
        description: '指定された都市の現在の天気を照会します',
        parameters: {
          type: 'object',
          properties: {
            city: {
              type: 'string',
              description: '都市名、例: 東京'
            },
            unit: {
              type: 'string',
              enum: ['celsius', 'fahrenheit']
            }
          },
          required: ['city']
        }
      }
    }
  ];

  const messages = [
    { role: 'user', content: '今の東京の天気はどうですか?' }
  ];

  // 第1ラウンド
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: messages,
    tools: tools,
    tool_choice: 'auto'
  });

  // ツール呼び出しを確認
  if (response.choices[0].message.tool_calls) {
    const toolCall = response.choices[0].message.tool_calls[0];
    const toolResult = '東京、晴れ、気温23度、湿度45%。';

    // 第2ラウンド
    messages.push(response.choices[0].message);
    messages.push({
      role: 'tool',
      tool_call_id: toolCall.id,
      content: toolResult
    });

    const finalResponse = await client.chat.completions.create({
      model: 'gpt-5.5',
      messages: messages,
      tools: tools
    });

    console.log(finalResponse.choices[0].message.content);
  }
}

// 構造化出力
async function structuredOutput() {
  const response = await client.chat.completions.create({
    model: 'gpt-5.5',
    messages: [
      {
        role: 'user',
        content: '次のテキストから重要な情報を抽出してください: RouteAPIは、OpenAI、Claude、Geminiなどのモデルをサポートする AI APIゲートウェイです。'
      }
    ],
    response_format: {
      type: 'json_schema',
      json_schema: {
        name: 'key_info',
        strict: true,
        schema: {
          type: 'object',
          properties: {
            product_name: { type: 'string' },
            category: { type: 'string' },
            supported_models: {
              type: 'array',
              items: { type: 'string' }
            }
          },
          required: ['product_name', 'category', 'supported_models'],
          additionalProperties: false
        }
      }
    }
  });

  console.log(response.choices[0].message.content);
}

// 例を実行
async function main() {
  await basicChat();
  console.log('\n' + '='.repeat(50) + '\n');
  await streamingChat();
  console.log('\n' + '='.repeat(50) + '\n');
  await toolCalling();
  console.log('\n' + '='.repeat(50) + '\n');
  await structuredOutput();
}

main().catch(console.error);

統合の推奨事項

クライアント、SDK、またはツールがOpenAI APIをネイティブにサポートしている場合は、OpenAI互換プロトコルを優先してください
モデルIDを固定し、本番環境では一時的なエイリアスや表示名に依存しないでください
リクエストメタデータを記録し、リクエストID、モデルID、ステータスコード、レイテンシ、トークン使用量を含めてください
失敗リトライを有効化し、コアビジネスフローに対してクライアントリトライと代替モデルオプションを有効にしてください
オプション機能を検証し、ツール呼び出し、構造化出力、ビジュアル入力などの機能をテスト環境で最初にテストしてください
コストとクォータを監視し、コンソールで使用ログと課金詳細を定期的に確認してください
API Keyを保護し、RouteAPI Tokenをサーバーサイドでカプセル化し、ビジネスフロントエンドに直接キーを公開しないでください

クライアントがClaude MessagesまたはGoogle Geminiプロトコルのみをサポートしている場合は、対応するプロトコルエンドポイントを使用してください。Claude MessagesおよびGemini APIのドキュメントをご参照ください。