screenshot-to-code

Upgrade to the latest release containing the fix for issue #599. As a temporary workaround, downgrade to the previous major version. To patch the code, import WebSocketDisconnect from Starlette and make WebSocketCommunicator.close() and throw_error() handle the already-closed state, for example:

from starlette.websockets import WebSocketDisconnect

try:
    await ws_comm.close()
except (
    ConnectionClosedOK,
    ConnectionClosedError,
    WebSocketDisconnect,
    RuntimeError,
):
    pass

Apply the same exception handling in throw_error(). This prevents the finally block from sending another websocket.close ASGI message after uvicorn has already closed the connection. The crash was observed with Python 3.11, uvicorn 0.25.0, Starlette 0.41.3, and websockets 14.1.

Wrap the client lifecycle in try/finally so close() runs even if streaming or session initialization fails:

client = AsyncAnthropic(api_key=api_key)
try:
    # streaming / session logic
    ...
finally:
    await client.close()

Alternatively, use the client as an async context manager:

async with AsyncAnthropic(api_key=api_key) as client:
    # streaming logic
    ...

Apply the same pattern to AsyncOpenAI and to both stream_claude_response and stream_claude_response_native. Without cleanup, exceptions leave HTTP connections open, which can exhaust the connection pool in long-running services.

Check the backend logs first to identify the exact OpenAI error:

docker compose logs backend --tail=100
# or
docker logs <container_id>

Common fixes:

1. **Invalid or missing API key:** Ensure OPENAI_API_KEY is set correctly in your environment or .env file, then restart the container.
2. **Model not found or unavailable:** If generate_code.py pins a dated model such as gpt-4o-2024-11-20, change it to a model available on your OpenAI account, such as gpt-4o or gpt-4.
3. **Rate limit or account restriction:** Check your OpenAI billing/usage dashboard and reduce request frequency or wait for the rate limit to reset.
4. **Restart after configuration changes:** Run docker compose down && docker compose up --build.

For a permanent fix, add explicit OpenAI API error handling in generate_code.py so authentication, rate-limit, and model-not-found errors are surfaced instead of failing silently.

This is a network/DNS/proxy issue, not a problem with the typing-extensions package. In PowerShell, first test connectivity:

Resolve-DnsName pypi.org
Invoke-WebRequest https://pypi.org/simple/ -UseBasicParsing
poetry install -v

If you are behind a local proxy, set it before running Poetry (replace the port with your proxy port):

$env:HTTP_PROXY = "http://127.0.0.1:7890"
$env:HTTPS_PROXY = "http://127.0.0.1:7890"
poetry install

If PyPI is blocked on your network, use a mirror temporarily:

$env:POETRY_PYPI_MIRROR_URL = "https://pypi.tuna.tsinghua.edu.cn/simple/"
poetry install

Also try disabling or reconfiguring VPN/firewall software, then re-run poetry install.

This 422 error means messages[1].content uses a format DeepSeek does not accept. Although DeepSeek is OpenAI-compatible, it may not accept OpenAI's multimodal content-part arrays. Send message content as a plain text string instead.

Inspect the failing message:

import json
print(json.dumps(params["messages"][1], ensure_ascii=False, indent=2))

Convert content arrays to text before calling the API:

def normalize_deepseek_messages(messages):
    for message in messages:
        content = message.get("content")

        if isinstance(content, list):
            message["content"] = "".join(
                part.get("text", "")
                for part in content
                if isinstance(part, dict) and part.get("type") == "text"
            )
        elif content is None:
            message["content"] = ""

    return messages

params["messages"] = normalize_deepseek_messages(params["messages"])
stream = await client.chat.completions.create(**params)

Also remove unsupported parts such as image_url or input_audio; use DeepSeek's text/chat format only. If using an agent framework, disable vision/multimodal message formatting or force plain-text OpenAI-compatible messages.