OpenAI SDK v3.36.1 Released: Fixes WebSocket and Browser Invocation Issues

Title

OpenAI SDK v3.36.1 Released: Fixes WebSocket and Browser Invocation Issues

Meta Description

The OpenAI SDK v3.36.1 release fixes issues including per-call WebSocket query settings not taking effect, incorrect validation order of driver state in browser invocations, and the microphone not stopping between consecutive recordings, and refactors the chunked upload and vector store polling runtimes.

Article Content

The official OpenAI SDK released version v3.36.1 on October 22. This is a patch release focused primarily on bug fixes, covering four areas: the API, sample code, documentation, and internal runtime refactoring. For developers using this SDK to build real-time voice, browser-side invocation, or large file upload capabilities, this version resolves several pain points encountered in real-world usage.

Core Fixes: WebSocket and Browser Invocation

Per-call WebSocket Query Settings Now Take Effect

The most notable fix in this release is honor per-call WebSocket query settings in the API module (#4138). Previously, query parameter configuration for WebSocket connections might not take effect correctly within a single call, causing developer-supplied query settings to be ignored or overridden by global configuration. For scenarios relying on WebSocket, such as real-time voice and streaming conversations, this meant connection behavior diverged from expectations, and it was quite hard to diagnose. With the fix, WebSocket query parameters passed in each call are now properly respected, making multi-tenant or per-request customized connection parameters more reliable.

WebSocket is a protocol that provides full-duplex communication over a single TCP connection. Unlike ordinary HTTP requests that must re-establish a connection each time, it maintains a persistent connection after a single HTTP upgrade handshake, allowing the client and server to push data to each other at any time. This characteristic makes it a commonly used channel for low-latency scenarios such as real-time voice and streaming text generation. When establishing a WebSocket connection, the SDK typically appends query parameters to the handshake URL to convey the model name, session identifier, authentication token, or custom routing information. "Per-call take effect" means these parameters should be based on the values passed in a single call and should not be overridden by client-instance-level global defaults. If the merge logic is written incorrectly, the global configuration will silently override the parameters explicitly passed by the caller, manifesting as connections hitting the wrong endpoint or session—and such errors often only surface when server behavior becomes abnormal, which is why this type of fix is especially critical for multi-tenant scenarios.

Validate Driver State Before Browser Invocation

The sample code section fixes two issues. The first is validate browser calls before reading driver state (#4142): in browser environments, the code would read the driver state before performing validation—the order was reversed. This caused state to be read when the driver was not yet ready, throwing hard-to-understand errors. After adjusting to validate first and read afterward, error messages are closer to the real cause, and the runnability of the sample improves accordingly.

The other sample fix is stop microphone capture between recordings (#4143). In consecutive recording scenarios, microphone capture was not correctly stopped between two recordings, potentially causing resource consumption or audio data cross-talk. For developers copying the sample to build voice applications, such issues would directly manifest as recording anomalies.

Documentation and Refactoring: Paving the Way for Chunked Upload and Vector Store Polling

Clearer Documentation on Deleting Service Account API Keys

On the documentation side, this release clarifies the deletion process for service account API keys (#4151). Service account key management is a high-frequency operation in enterprise-level integrations, and unclear deletion semantics can easily lead to mistakes. This change does not involve code behavior itself, but it reduces the cognitive burden on the operations side.

Preparations for Handwritten Runtimes

The refactoring section includes two items: prepare handwritten chunked upload runtime (#4146) and prepare handwritten vector-store polling runtime (#4148). Both are "preparation"-style changes that do not yet change external behavior, but they send a signal: the SDK is organizing handwritten chunked upload logic and vector store polling logic into standalone runtimes. Chunked upload affects the stability of large-scale file writes, while vector store polling affects index synchronization efficiency in RAG scenarios. Such refactoring is typically groundwork for future feature expansion or performance optimization, and it is worth watching whether subsequent versions follow up.

Vector store polling is a common step in the RAG (Retrieval-Augmented Generation) workflow: after documents are uploaded to the vector store, index construction happens asynchronously, and the application needs to periodically query the index status until it becomes available before initiating retrieval. Polling logic looks simple but involves details such as backoff strategies, timeout limits, and deduplication of concurrent requests. Chunked upload refers to splitting large files into multiple parts for separate transmission and then merging them on the server side; it needs to handle part ordering, resumable transfer, failure retries, and integrity verification. These two pieces of logic were previously often scattered as handwritten code inside the SDK, making them hard to reuse and test. Organizing them into standalone runtimes means retry and concurrency strategies can be controlled uniformly going forward, and implementations can be swapped without affecting the public API—this is precisely the practical meaning of "preparation"-style commits.

How to Understand This Version

Judging by the version number, 3.36.1 is a patch-level update with no new APIs or breaking changes, so upgrade risk is low. Its value centers on "making existing capabilities work as expected": WebSocket query configuration finally takes effect per call, browser sample errors are more diagnosable, and consecutive recordings no longer interfere with each other. If your project involves real-time voice or browser-side invocation, it is advisable to upgrade as soon as possible; if you only use the basic text completion interface, the urgency is lower, but there is no obvious obstacle either.

One caveat: this release information comes from the GitHub Release page, and the content consists mainly of commit records and fix entries; the official team did not include migration notes. Before upgrading, it is recommended to verify WebSocket-related call paths in a test environment to confirm that query parameter passing behavior meets expectations.

One-line Summary

OpenAI SDK releases v3.36.1 patch, fixing WebSocket query settings, browser samples, and recording issues.

Paragraph Summary

On October 22, the official OpenAI SDK released the v3.36.1 patch, focused primarily on bug fixes and covering four areas: the API, sample code, documentation, and internal refactoring. The core change fixes the issue where WebSocket query parameters could not take effect on a per-call basis, making multi-tenant or per-request customized connection parameters more reliable in real-time voice and streaming conversation scenarios. In sample code, browser invocations now validate before reading driver state, making error messages easier to diagnose; in consecutive recording scenarios, microphone capture now stops correctly between two recordings. Documentation clarifies the deletion notes for service account API keys, and the refactoring section prepares standalone runtimes for chunked upload and vector store polling. This version has no breaking changes and low upgrade risk; projects involving real-time voice or browser-side invocation should upgrade soon, and first verify WebSocket call paths in a test environment.