Update app.py and add model discovery tools

.github/workflows/docker-publish.yml

@@ -1,98 +0,0 @@
-name: Docker
-
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-on:
-  schedule:
-    - cron: '17 23 * * *'
-  push:
-    branches: [ "main" ]
-    # Publish semver tags as releases.
-    tags: [ 'v*.*.*' ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  # Use docker.io for Docker Hub if empty
-  REGISTRY: ghcr.io
-  # github.repository as <account>/<repo>
-  IMAGE_NAME: ${{ github.repository }}
-
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-      # This is used to complete the identity challenge
-      # with sigstore/fulcio when running outside of PRs.
-      id-token: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      # Install the cosign tool except on PR
-      # https://github.com/sigstore/cosign-installer
-      - name: Install cosign
-        if: github.event_name != 'pull_request'
-        uses: sigstore/cosign-installer@59acb6260d9c0ba8f4a2f9d9b48431a222b68e20 #v3.5.0
-        with:
-          cosign-release: 'v2.2.4'
-
-      # Set up BuildKit Docker container builder to be able to build
-      # multi-platform images and export cache
-      # https://github.com/docker/setup-buildx-action
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@f95db51fddba0c2d1ec667646a06c2ce06100226 # v3.0.0
-
-      # Login against a Docker registry except on PR
-      # https://github.com/docker/login-action
-      - name: Log into registry ${{ env.REGISTRY }}
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@343f7c4344506bcbf9b4de18042ae17996df046d # v3.0.0
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Extract metadata (tags, labels) for Docker
-      # https://github.com/docker/metadata-action
-      - name: Extract Docker metadata
-        id: meta
-        uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 # v5.0.0
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-
-      # Build and push Docker image with Buildx (don't push on PR)
-      # https://github.com/docker/build-push-action
-      - name: Build and push Docker image
-        id: build-and-push
-        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0
-        with:
-          context: .
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-
-      # Sign the resulting Docker image digest except on PRs.
-      # This will only write to the public Rekor transparency log when the Docker
-      # repository is public to avoid leaking data.  If you would like to publish
-      # transparency data even for private images, pass --force to cosign below.
-      # https://github.com/sigstore/cosign
-      - name: Sign the published Docker image
-        if: ${{ github.event_name != 'pull_request' }}
-        env:
-          # https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions#using-an-intermediate-environment-variable
-          TAGS: ${{ steps.meta.outputs.tags }}
-          DIGEST: ${{ steps.build-and-push.outputs.digest }}
-        # This step uses the identity token to provision an ephemeral certificate
-        # against the sigstore community Fulcio instance.
-        run: echo "${TAGS}" | xargs -I {} cosign sign --yes {}@${DIGEST}

app.py

@@ -374,6 +374,24 @@ def _openai_non_streaming_response(text: str, model: Optional[str]) -> Dict[str,
 def _sse_format(obj: Dict[str, Any]) -> str:
     return f"data: {json.dumps(obj, ensure_ascii=False)}\n\n"
 
+@app.get("/v1/models")
+def list_models():
+    """
+    OpenAI-compatible models endpoint.
+    Returns the available models that can be used with this API.
+    """
+    return {
+        "object": "list",
+        "data": [
+            {
+                "id": "claude-sonnet-4",
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "amazon-q"
+            }
+        ]
+    }
+
 @app.post("/v1/chat/completions")
 def chat_completions(req: ChatCompletionRequest, account: Dict[str, Any] = Depends(require_account)):
     """

available_models.txt

@@ -0,0 +1,2 @@
+可用模型列表:
+claude-sonnet-4

check_docs.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""
+检查 API 文档和规范
+"""
+
+import requests
+import json
+
+def check_openapi_spec():
+    """检查 OpenAPI 规范"""
+    try:
+        response = requests.get("http://localhost:8000/openapi.json", timeout=10)
+        if response.status_code == 200:
+            spec = response.json()
+            
+            print("📋 OpenAPI 规范分析")
+            print("=" * 50)
+            
+            # 查找模型相关的信息
+            def find_model_info(obj, path=""):
+                models_found = []
+                
+                if isinstance(obj, dict):
+                    for key, value in obj.items():
+                        current_path = f"{path}.{key}" if path else key
+                        
+                        if "model" in key.lower() or "claude" in key.lower() or "anthropic" in key.lower():
+                            models_found.append((current_path, value))
+                        
+                        models_found.extend(find_model_info(value, current_path))
+                
+                elif isinstance(obj, list):
+                    for i, item in enumerate(obj):
+                        models_found.extend(find_model_info(item, f"{path}[{i}]"))
+                
+                return models_found
+            
+            model_info = find_model_info(spec)
+            
+            if model_info:
+                print("🔍 发现模型相关信息:")
+                for path, value in model_info[:10]:  # 只显示前10个
+                    print(f"  {path}: {value}")
+            else:
+                print("❌ 未在 OpenAPI 规范中发现模型信息")
+            
+            # 检查 schemas
+            if "components" in spec and "schemas" in spec["components"]:
+                schemas = spec["components"]["schemas"]
+                print(f"\n📝 发现 {len(schemas)} 个 schema:")
+                for schema_name in schemas.keys():
+                    print(f"  • {schema_name}")
+            
+            # 保存完整规范
+            with open("openapi_spec.json", "w", encoding="utf-8") as f:
+                json.dump(spec, f, ensure_ascii=False, indent=2)
+            print(f"\n📁 完整 OpenAPI 规范已保存到: openapi_spec.json")
+            
+        else:
+            print(f"❌ 获取 OpenAPI 规范失败: {response.status_code}")
+    
+    except Exception as e:
+        print(f"❌ 检查 OpenAPI 规范异常: {e}")
+
+def check_docs_page():
+    """检查文档页面"""
+    try:
+        response = requests.get("http://localhost:8000/docs", timeout=10)
+        if response.status_code == 200:
+            print("📖 /docs 页面可访问")
+            print("建议在浏览器中访问 http://localhost:8000/docs 查看完整文档")
+        else:
+            print(f"❌ /docs 页面不可访问: {response.status_code}")
+    except Exception as e:
+        print(f"❌ 检查 /docs 页面异常: {e}")
+
+if __name__ == "__main__":
+    check_openapi_spec()
+    check_docs_page()

discover_models.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+尝试获取 Amazon Q API 支持的所有模型
+"""
+
+import requests
+import json
+import re
+from typing import List, Dict, Optional
+
+BASE_URL = "http://localhost:8000"
+
+def try_models_endpoint():
+    """尝试调用 /v1/models 端点（如果存在）"""
+    try:
+        response = requests.get(f"{BASE_URL}/v1/models", timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            print("✅ 发现 /v1/models 端点")
+            return data
+        else:
+            print(f"❌ /v1/models 端点返回: {response.status_code}")
+            return None
+    except Exception as e:
+        print(f"❌ /v1/models 端点异常: {e}")
+        return None
+
+def extract_model_from_error(error_text: str) -> List[str]:
+    """从错误信息中提取可能的模型名称"""
+    models = []
+    
+    # 常见的模型名称模式
+    patterns = [
+        r'claude-[\w\.-]+',
+        r'anthropic\.[\w\.-]+',
+        r'model\s+["\']?([a-zA-Z0-9_\.-]+)["\']?',
+        r'available\s+models?[:\s]+([^\n\r]+)',
+        r'supported\s+models?[:\s]+([^\n\r]+)',
+    ]
+    
+    for pattern in patterns:
+        matches = re.findall(pattern, error_text, re.IGNORECASE)
+        models.extend(matches)
+    
+    return list(set(models))  # 去重
+
+def try_common_amazon_q_models() -> List[str]:
+    """尝试 Amazon Q 可能支持的其他模型名称"""
+    # 基于 AWS Bedrock 和 Amazon Q 的常见模型命名
+    amazon_q_models = [
+        # Claude 模型 (AWS Bedrock 格式)
+        "anthropic.claude-v2:1",
+        "anthropic.claude-v2",
+        "anthropic.claude-instant-v1",
+        "anthropic.claude-3-sonnet-20240229-v1:0",
+        "anthropic.claude-3-sonnet-20240229-v1",
+        "anthropic.claude-3-haiku-20240307-v1:0", 
+        "anthropic.claude-3-haiku-20240307-v1",
+        "anthropic.claude-3-opus-20240229-v1:0",
+        "anthropic.claude-3-opus-20240229-v1",
+        
+        # Amazon Q 特定模型
+        "amazon.q",
+        "amazon.q-turbo",
+        "amazon.q-pro",
+        "amazon.q-max",
+        "q.amazon",
+        "q-turbo.amazon",
+        "q-pro.amazon",
+        "q-max.amazon",
+        
+        # 其他可能的命名
+        "claude",
+        "claude-v2",
+        "claude-instant",
+        "claude-3-sonnet",
+        "claude-3-haiku", 
+        "claude-3-opus",
+        "sonnet",
+        "haiku",
+        "opus",
+        
+        # 通用模型名
+        "default",
+        "base",
+        "latest",
+        "text-davinci-003",  # 测试是否支持OpenAI模型名
+        "gpt-3.5-turbo",
+        "gpt-4",
+    ]
+    
+    return amazon_q_models
+
+def test_model_with_details(model_name: str) -> Dict[str, any]:
+    """详细测试单个模型"""
+    url = f"{BASE_URL}/v1/chat/completions"
+    
+    payload = {
+        "model": model_name,
+        "messages": [
+            {"role": "user", "content": "test"}
+        ],
+        "stream": False,
+        "max_tokens": 5
+    }
+    
+    try:
+        response = requests.post(url, json=payload, timeout=15)
+        
+        result = {
+            "model": model_name,
+            "status_code": response.status_code,
+            "available": response.status_code == 200,
+            "error": None,
+            "error_details": None
+        }
+        
+        if response.status_code != 200:
+            result["error"] = response.text[:300]
+            # 尝试从错误中提取模型信息
+            extracted_models = extract_model_from_error(response.text)
+            if extracted_models:
+                result["extracted_models"] = extracted_models
+        
+        return result
+        
+    except Exception as e:
+        return {
+            "model": model_name,
+            "status_code": None,
+            "available": False,
+            "error": str(e),
+            "error_details": None
+        }
+
+def comprehensive_model_search():
+    """全面搜索可用模型"""
+    print("🔍 全面搜索 Amazon Q API 支持的模型")
+    print("=" * 60)
+    
+    # 1. 尝试标准 models 端点
+    print("\n1️⃣ 尝试标准 /v1/models 端点...")
+    models_data = try_models_endpoint()
+    if models_data:
+        print("发现模型列表:")
+        if isinstance(models_data, dict) and "data" in models_data:
+            for model in models_data["data"]:
+                print(f"  • {model.get('id', 'unknown')}")
+        elif isinstance(models_data, list):
+            for model in models_data:
+                if isinstance(model, dict):
+                    print(f"  • {model.get('id', model.get('model', 'unknown'))}")
+                else:
+                    print(f"  • {model}")
+        return models_data
+    
+    # 2. 测试更多模型名称
+    print("\n2️⃣ 测试扩展的模型名称列表...")
+    additional_models = try_common_amazon_q_models()
+    
+    print(f"测试 {len(additional_models)} 个额外的模型名称...")
+    
+    available_models = []
+    error_models = []
+    extracted_from_errors = set()
+    
+    for i, model in enumerate(additional_models, 1):
+        print(f"[{i}/{len(additional_models)}] {model}...", end=" ")
+        
+        result = test_model_with_details(model)
+        
+        if result["available"]:
+            print("✅")
+            available_models.append(model)
+        else:
+            print("❌")
+            error_models.append((model, result["error"]))
+            
+            # 从错误中提取模型信息
+            if "extracted_models" in result:
+                extracted_from_errors.update(result["extracted_models"])
+        
+        # 避免请求过快
+        import time
+        time.sleep(0.3)
+    
+    # 3. 输出结果
+    print("\n" + "=" * 60)
+    print("📊 搜索结果")
+    print("=" * 60)
+    
+    if available_models:
+        print(f"\n✅ 发现可用模型 ({len(available_models)} 个):")
+        for model in available_models:
+            print(f"  • {model}")
+    else:
+        print("\n❌ 没有发现新的可用模型")
+    
+    if extracted_from_errors:
+        print(f"\n🔍 从错误信息中提取的可能模型 ({len(extracted_from_errors)} 个):")
+        for model in sorted(extracted_from_errors):
+            print(f"  • {model}")
+    
+    # 4. 保存结果
+    search_results = {
+        "available_models": available_models,
+        "error_models": [{"model": m, "error": e} for m, e in error_models[:10]],  # 只保存前10个错误
+        "extracted_from_errors": list(extracted_from_errors),
+        "timestamp": str(time.time())
+    }
+    
+    with open("model_search_results.json", "w", encoding="utf-8") as f:
+        json.dump(search_results, f, ensure_ascii=False, indent=2)
+    
+    print(f"\n📁 详细结果已保存到: model_search_results.json")
+    
+    return search_results
+
+def inspect_api_info():
+    """检查API的其他信息端点"""
+    endpoints_to_try = [
+        "/",
+        "/docs", 
+        "/openapi.json",
+        "/info",
+        "/v1",
+        "/status",
+        "/health"
+    ]
+    
+    print("\n🔍 检查API信息端点...")
+    
+    for endpoint in endpoints_to_try:
+        try:
+            response = requests.get(f"{BASE_URL}{endpoint}", timeout=5)
+            if response.status_code == 200:
+                print(f"✅ {endpoint} - 可访问")
+                # 检查是否包含模型信息
+                content = response.text.lower()
+                if any(keyword in content for keyword in ["model", "claude", "anthropic"]):
+                    print(f"   📄 可能包含模型相关信息")
+            else:
+                print(f"❌ {endpoint} - {response.status_code}")
+        except:
+            print(f"❌ {endpoint} - 连接失败")
+
+if __name__ == "__main__":
+    import time
+    
+    # 检查API信息端点
+    inspect_api_info()
+    
+    # 全面模型搜索
+    comprehensive_model_search()
+    
+    print("\n✨ 搜索完成!")

model_search_results.json

@@ -0,0 +1,47 @@
+{
+  "available_models": [],
+  "error_models": [
+    {
+      "model": "anthropic.claude-v2:1",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-v2",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-instant-v1",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-3-sonnet-20240229-v1:0",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-3-sonnet-20240229-v1",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-3-haiku-20240307-v1:0",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-3-haiku-20240307-v1",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-3-opus-20240229-v1:0",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "anthropic.claude-3-opus-20240229-v1",
+      "error": "Internal Server Error"
+    },
+    {
+      "model": "amazon.q",
+      "error": "Internal Server Error"
+    }
+  ],
+  "extracted_from_errors": [],
+  "timestamp": "1763807315.45737"
+}

openapi_spec.json

@@ -0,0 +1,699 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "v2 OpenAI-compatible Server (Amazon Q Backend)",
+    "version": "0.1.0"
+  },
+  "paths": {
+    "/v1/chat/completions": {
+      "post": {
+        "summary": "Chat Completions",
+        "description": "OpenAI-compatible chat endpoint.\n    - stream default False\n    - messages will be converted into \"{role}:\n{content}\" and injected into template\n    - account is chosen randomly among enabled accounts (API key is for authorization only)",
+        "operationId": "chat_completions_v1_chat_completions_post",
+        "parameters": [
+          {
+            "name": "authorization",
+            "in": "header",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "title": "Authorization"
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ChatCompletionRequest"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v2/auth/start": {
+      "post": {
+        "summary": "Auth Start",
+        "description": "Start device authorization and return verification URL for user login.\nSession lifetime capped at 5 minutes on claim.",
+        "operationId": "auth_start_v2_auth_start_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/AuthStartBody"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v2/auth/status/{auth_id}": {
+      "get": {
+        "summary": "Auth Status",
+        "operationId": "auth_status_v2_auth_status__auth_id__get",
+        "parameters": [
+          {
+            "name": "auth_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Auth Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v2/auth/claim/{auth_id}": {
+      "post": {
+        "summary": "Auth Claim",
+        "description": "Block up to 5 minutes to exchange the device code for tokens after user completed login.\nOn success, creates an enabled account and returns it.",
+        "operationId": "auth_claim_v2_auth_claim__auth_id__post",
+        "parameters": [
+          {
+            "name": "auth_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Auth Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v2/accounts": {
+      "get": {
+        "summary": "List Accounts",
+        "operationId": "list_accounts_v2_accounts_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "summary": "Create Account",
+        "operationId": "create_account_v2_accounts_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/AccountCreate"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v2/accounts/{account_id}": {
+      "get": {
+        "summary": "Get Account Detail",
+        "operationId": "get_account_detail_v2_accounts__account_id__get",
+        "parameters": [
+          {
+            "name": "account_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Account Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "summary": "Delete Account",
+        "operationId": "delete_account_v2_accounts__account_id__delete",
+        "parameters": [
+          {
+            "name": "account_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Account Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      },
+      "patch": {
+        "summary": "Update Account",
+        "operationId": "update_account_v2_accounts__account_id__patch",
+        "parameters": [
+          {
+            "name": "account_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Account Id"
+            }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/AccountUpdate"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v2/accounts/{account_id}/refresh": {
+      "post": {
+        "summary": "Manual Refresh",
+        "operationId": "manual_refresh_v2_accounts__account_id__refresh_post",
+        "parameters": [
+          {
+            "name": "account_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Account Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/": {
+      "get": {
+        "summary": "Index",
+        "operationId": "index__get",
+        "responses": {
+          "200": {
+            "description": "Successful Response"
+          }
+        }
+      }
+    },
+    "/healthz": {
+      "get": {
+        "summary": "Health",
+        "operationId": "health_healthz_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "AccountCreate": {
+        "properties": {
+          "label": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Label"
+          },
+          "clientId": {
+            "type": "string",
+            "title": "Clientid"
+          },
+          "clientSecret": {
+            "type": "string",
+            "title": "Clientsecret"
+          },
+          "refreshToken": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Refreshtoken"
+          },
+          "accessToken": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Accesstoken"
+          },
+          "other": {
+            "anyOf": [
+              {
+                "type": "object"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Other"
+          },
+          "enabled": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Enabled",
+            "default": true
+          }
+        },
+        "type": "object",
+        "required": [
+          "clientId",
+          "clientSecret"
+        ],
+        "title": "AccountCreate"
+      },
+      "AccountUpdate": {
+        "properties": {
+          "label": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Label"
+          },
+          "clientId": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Clientid"
+          },
+          "clientSecret": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Clientsecret"
+          },
+          "refreshToken": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Refreshtoken"
+          },
+          "accessToken": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Accesstoken"
+          },
+          "other": {
+            "anyOf": [
+              {
+                "type": "object"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Other"
+          },
+          "enabled": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Enabled"
+          }
+        },
+        "type": "object",
+        "title": "AccountUpdate"
+      },
+      "AuthStartBody": {
+        "properties": {
+          "label": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Label"
+          },
+          "enabled": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Enabled",
+            "default": true
+          }
+        },
+        "type": "object",
+        "title": "AuthStartBody"
+      },
+      "ChatCompletionRequest": {
+        "properties": {
+          "model": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Model"
+          },
+          "messages": {
+            "items": {
+              "$ref": "#/components/schemas/ChatMessage"
+            },
+            "type": "array",
+            "title": "Messages"
+          },
+          "stream": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Stream",
+            "default": false
+          }
+        },
+        "type": "object",
+        "required": [
+          "messages"
+        ],
+        "title": "ChatCompletionRequest"
+      },
+      "ChatMessage": {
+        "properties": {
+          "role": {
+            "type": "string",
+            "title": "Role"
+          },
+          "content": {
+            "title": "Content"
+          }
+        },
+        "type": "object",
+        "required": [
+          "role",
+          "content"
+        ],
+        "title": "ChatMessage"
+      },
+      "HTTPValidationError": {
+        "properties": {
+          "detail": {
+            "items": {
+              "$ref": "#/components/schemas/ValidationError"
+            },
+            "type": "array",
+            "title": "Detail"
+          }
+        },
+        "type": "object",
+        "title": "HTTPValidationError"
+      },
+      "ValidationError": {
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "ValidationError"
+      }
+    }
+  }
+}

query_amazon_models.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+直接查询 Amazon Q 服务来获取支持的模型
+"""
+
+import requests
+import json
+import time
+from replicate import send_chat_request
+
+def get_available_models_from_amazon_q():
+    """尝试通过特殊查询获取 Amazon Q 支持的模型"""
+    
+    # 尝试不同的查询方式来获取模型信息
+    test_queries = [
+        "你支持哪些模型？",
+        "有哪些可用的模型？", 
+        "列出所有支持的模型名称",
+        "What models are available?",
+        "List all supported models",
+        "Show model options",
+        "model list",
+        "models",
+        "help"
+    ]
+    
+    print("🔍 通过查询尝试获取 Amazon Q 支持的模型信息")
+    print("=" * 60)
+    
+    # 这里需要一个有效的 access token，我们先尝试从现有账号获取
+    try:
+        # 检查是否有可用账号
+        accounts_response = requests.get("http://localhost:8000/v2/accounts", timeout=10)
+        if accounts_response.status_code != 200:
+            print("❌ 无法获取账号信息")
+            return
+        
+        accounts = accounts_response.json()
+        enabled_accounts = [acc for acc in accounts if acc.get("enabled", False)]
+        
+        if not enabled_accounts:
+            print("❌ 没有可用的账号")
+            return
+        
+        account = enabled_accounts[0]
+        access_token = account.get("accessToken")
+        
+        if not access_token:
+            # 尝试刷新 token
+            print("🔄 刷新 access token...")
+            refresh_response = requests.post(f"http://localhost:8000/v2/accounts/{account['id']}/refresh", timeout=10)
+            if refresh_response.status_code == 200:
+                updated_account = refresh_response.json()
+                access_token = updated_account.get("accessToken")
+        
+        if not access_token:
+            print("❌ 无法获取 access token")
+            return
+        
+        print(f"✅ 获取到 access token，开始查询...")
+        
+        # 对每个查询进行测试
+        for i, query in enumerate(test_queries, 1):
+            print(f"\n[{i}/{len(test_queries)}] 查询: {query}")
+            print("-" * 40)
+            
+            try:
+                text, _, tracker = send_chat_request(
+                    access_token, 
+                    [{"role": "user", "content": query}], 
+                    model=None,  # 不指定模型，使用默认
+                    stream=False,
+                    timeout=(10, 30)
+                )
+                
+                if text:
+                    print(f"响应: {text[:200]}...")
+                    
+                    # 检查响应中是否包含模型信息
+                    model_keywords = ["model", "claude", "anthropic", "sonnet", "haiku", "opus"]
+                    found_models = []
+                    
+                    for keyword in model_keywords:
+                        if keyword.lower() in text.lower():
+                            found_models.append(keyword)
+                    
+                    if found_models:
+                        print(f"🔍 发现模型相关关键词: {', '.join(found_models)}")
+                else:
+                    print("❌ 无响应")
+                
+            except Exception as e:
+                print(f"❌ 查询失败: {e}")
+            
+            time.sleep(1)  # 避免请求过快
+    
+    except Exception as e:
+        print(f"❌ 获取模型信息失败: {e}")
+
+def test_model_variations():
+    """测试模型名称的变体"""
+    # 基于已知可用的 claude-sonnet-4，测试可能的变体
+    variations = [
+        "claude-sonnet-4",
+        "Claude-Sonnet-4", 
+        "CLAUDE-SONNET-4",
+        "sonnet-4",
+        "claude-4-sonnet",
+        "claude-4",
+        "sonnet4",
+        "anthropic-sonnet-4",
+        "anthropic-claude-sonnet-4",
+    ]
+    
+    print("\n🧪 测试模型名称变体")
+    print("=" * 40)
+    
+    for model in variations:
+        try:
+            text, _, tracker = send_chat_request(
+                "dummy_token",  # 这里会被替换为真实 token
+                [{"role": "user", "content": "test"}], 
+                model=model,
+                stream=False,
+                timeout=(5, 15)
+            )
+            
+            if text:
+                print(f"✅ {model} - 可用")
+            else:
+                print(f"❌ {model} - 不可用")
+                
+        except Exception as e:
+            print(f"❌ {model} - 错误: {str(e)[:50]}")
+        
+        time.sleep(0.5)
+
+if __name__ == "__main__":
+    get_available_models_from_amazon_q()
+    # test_model_variations()  # 暂时不运行，因为需要有效token

quick_test.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+简单的 Amazon Q API 测试脚本
+"""
+
+import requests
+import json
+
+def test_api():
+    """测试 API 基本功能"""
+    url = "http://localhost:8000/v1/chat/completions"
+    
+    payload = {
+        "model": "claude-sonnet-4",
+        "messages": [
+            {"role": "user", "content": "你好，请简单介绍一下你自己"}
+        ],
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(url, json=payload, timeout=30)
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
+            print("✅ API 测试成功!")
+            print(f"响应内容: {content}")
+            return True
+        else:
+            print(f"❌ API 测试失败: {response.status_code}")
+            print(f"错误信息: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ 请求异常: {e}")
+        return False
+
+def test_streaming():
+    """测试流式响应"""
+    url = "http://localhost:8000/v1/chat/completions"
+    
+    payload = {
+        "model": "claude-sonnet-4",
+        "messages": [
+            {"role": "user", "content": "请用一句话介绍人工智能"}
+        ],
+        "stream": True
+    }
+    
+    try:
+        response = requests.post(url, json=payload, stream=True, timeout=30)
+        
+        if response.status_code == 200:
+            print("✅ 流式测试成功!")
+            print("流式响应:")
+            for line in response.iter_lines():
+                if line:
+                    line_str = line.decode('utf-8')
+                    if line_str.startswith('data: ') and line_str != 'data: [DONE]':
+                        data = json.loads(line_str[6:])
+                        content = data.get("choices", [{}])[0].get("delta", {}).get("content", "")
+                        if content:
+                            print(content, end='', flush=True)
+            print()  # 换行
+            return True
+        else:
+            print(f"❌ 流式测试失败: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ 流式请求异常: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🧪 Amazon Q API 快速测试")
+    print("=" * 40)
+    
+    # 测试基本功能
+    print("1. 测试基本对话功能...")
+    test_api()
+    
+    print("\n2. 测试流式响应...")
+    test_streaming()
+    
+    print("\n✨ 测试完成!")

test_models.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+测试 Amazon Q API 可用模型的脚本
+"""
+
+import requests
+import json
+import time
+from typing import List, Dict, Optional
+
+# API 配置
+BASE_URL = "http://localhost:8000"
+API_KEY = ""  # 根据你的 .env 配置设置，如果为空则使用开发模式
+
+# 常见的 Claude 模型列表（基于 Amazon Q 可能支持的模型）
+TEST_MODELS = [
+    "claude-sonnet-4",
+    "claude-sonnet-3.5", 
+    "claude-haiku-3.5",
+    "claude-opus-3",
+    "claude-sonnet-3",
+    "claude-haiku-3",
+    "claude-instant-1.2",
+    "anthropic.claude-3-sonnet-20240229-v1:0",
+    "anthropic.claude-3-haiku-20240307-v1:0",
+    "anthropic.claude-3-opus-20240229-v1:0",
+]
+
+def test_model(model_name: str, api_key: str = "") -> Dict[str, any]:
+    """测试单个模型是否可用"""
+    url = f"{BASE_URL}/v1/chat/completions"
+    
+    headers = {
+        "Content-Type": "application/json",
+    }
+    
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    
+    payload = {
+        "model": model_name,
+        "messages": [
+            {"role": "user", "content": "请简单回复：你好"}
+        ],
+        "stream": False,
+        "max_tokens": 10
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        
+        result = {
+            "model": model_name,
+            "status_code": response.status_code,
+            "available": response.status_code == 200,
+            "error": None,
+            "response_preview": None
+        }
+        
+        if response.status_code == 200:
+            try:
+                data = response.json()
+                content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+                result["response_preview"] = content[:100]  # 只显示前100个字符
+            except:
+                result["response_preview"] = "解析响应失败"
+        else:
+            result["error"] = response.text[:200]  # 只显示前200个字符的错误信息
+            
+    except requests.exceptions.Timeout:
+        result = {
+            "model": model_name,
+            "status_code": None,
+            "available": False,
+            "error": "请求超时",
+            "response_preview": None
+        }
+    except Exception as e:
+        result = {
+            "model": model_name,
+            "status_code": None,
+            "available": False,
+            "error": str(e)[:200],
+            "response_preview": None
+        }
+    
+    return result
+
+def check_api_health() -> bool:
+    """检查 API 服务是否健康"""
+    try:
+        response = requests.get(f"{BASE_URL}/healthz", timeout=10)
+        return response.status_code == 200
+    except:
+        return False
+
+def check_accounts() -> bool:
+    """检查是否有可用账号"""
+    try:
+        headers = {"Authorization": f"Bearer {API_KEY}"} if API_KEY else {}
+        response = requests.get(f"{BASE_URL}/v2/accounts", headers=headers, timeout=10)
+        if response.status_code == 200:
+            accounts = response.json()
+            enabled_accounts = [acc for acc in accounts if acc.get("enabled", False)]
+            return len(enabled_accounts) > 0
+        return False
+    except:
+        return False
+
+def main():
+    """主函数"""
+    print("🔍 Amazon Q API 模型测试脚本")
+    print("=" * 50)
+    
+    # 检查 API 服务状态
+    print("📡 检查 API 服务状态...")
+    if not check_api_health():
+        print("❌ API 服务不可用，请确保服务正在运行在 http://localhost:8000")
+        return
+    
+    print("✅ API 服务正常")
+    
+    # 检查账号状态
+    print("👤 检查可用账号...")
+    if not check_accounts():
+        print("❌ 没有可用的账号，请先添加并启用 Amazon Q 账号")
+        return
+    
+    print("✅ 发现可用账号")
+    
+    # 测试模型
+    print(f"\n🧪 开始测试 {len(TEST_MODELS)} 个模型...")
+    print("-" * 80)
+    
+    available_models = []
+    failed_models = []
+    
+    for i, model in enumerate(TEST_MODELS, 1):
+        print(f"[{i}/{len(TEST_MODELS)}] 测试: {model}...", end=" ")
+        
+        result = test_model(model, API_KEY)
+        
+        if result["available"]:
+            print("✅ 可用")
+            available_models.append(model)
+            if result["response_preview"]:
+                print(f"    响应预览: {result['response_preview']}")
+        else:
+            print("❌ 不可用")
+            failed_models.append((model, result["error"]))
+        
+        # 避免请求过于频繁
+        time.sleep(0.5)
+    
+    # 输出结果总结
+    print("\n" + "=" * 80)
+    print("📊 测试结果总结")
+    print("=" * 80)
+    
+    if available_models:
+        print(f"\n✅ 可用模型 ({len(available_models)} 个):")
+        for model in available_models:
+            print(f"  • {model}")
+    else:
+        print("\n❌ 没有发现可用的模型")
+    
+    if failed_models:
+        print(f"\n❌ 不可用模型 ({len(failed_models)} 个):")
+        for model, error in failed_models[:5]:  # 只显示前5个错误
+            print(f"  • {model}: {error}")
+        if len(failed_models) > 5:
+            print(f"  ... 还有 {len(failed_models) - 5} 个模型不可用")
+    
+    # 生成配置建议
+    if available_models:
+        print(f"\n💡 建议配置:")
+        print(f"推荐使用: {available_models[0]}")
+        print(f"在代码中使用: model = \"{available_models[0]}\"")
+        
+        # 保存可用模型到文件
+        with open("available_models.txt", "w", encoding="utf-8") as f:
+            f.write("可用模型列表:\n")
+            for model in available_models:
+                f.write(f"{model}\n")
+        print(f"📁 可用模型已保存到: available_models.txt")
+
+if __name__ == "__main__":
+    main()