openai/openai-python
61.7
Adequate · 3 November 2026
201.3k
lines of production code
Python
primary language
4
measurements over time
What this system is
Features
Add Containers API resource with network and skill configuration
The SDK now exposes a new \Containers\ resource (sync and async) for managing containerized environments. Users can create, list, and retrieve containers, with support for configuring memory limits, network policies, and skills during creation. The implementation uses the \httpx2\ HTTP client and includes lazy loading for sub-resources like container files.
src/openai/resources/containers · high confidence
Add Responses WebSocket session and accumulator helpers
New \ResponsesWebSocketSession\ and \AsyncResponsesWebSocketSession\ classes are now available to manage routed lanes and collect final responses over a WebSocket connection, allowing users to send and receive structured responses with configurable event and byte limits. Additionally, a \ResponsesWebSocketAccumulator\ helper is provided to opt into incremental text and tool snapshots, enabling applications to build progressive UI updates and retrieve detailed, immutable snapshots of accumulated output items without executing tools. Also in this area: 3 commits (0 fixes) modifying openai, src/openai.
_src/openai/lib/responses\websocket · medium confidence · unverified
Add X.509 workload identity authentication support
Users can now authenticate using X.509 workload identity federation. This change introduces new \X509WorkloadIdentity\ and \WorkloadIdentityAuth\ classes, along with helper functions like \x509\_workload\_identity\, \k8s\_service\_account\_token\_provider\, \azure\_managed\_identity\_token\_provider\, and \gcp\_id\_token\_provider\ in the \src/openai/auth\ module. These tools allow the client to automatically obtain and refresh subject tokens from cloud provider metadata servers (Kubernetes, Azure, GCP) or use client certificates for mutual TLS (mTLS) authentication against OpenAI's MTLS endpoints.
src/openai/auth · high confidence
Add local audio recording and playback helpers
New helper classes \Microphone\ and \LocalAudioPlayer\ are now available in the \src/openai/helpers\ module to enable local audio capture and playback. The \Microphone\ class allows recording audio from the system's input device into NumPy arrays or WAV files, while \LocalAudioPlayer\ provides methods to play audio data (including streaming TTS responses) through the system's output device. These utilities rely on \numpy\ and \sounddevice\ for low-level audio handling.
src/openai/helpers · high confidence
Add safety cases and alerts API resources
The \src/openai/resources/safety\ module now exposes new API resources for retrieving safety cases and safety alerts. Users can access these via \client.safety.cases.retrieve(id)\ and \client.safety.alerts.retrieve(id)\ (and their async counterparts), supporting both standard and raw/streaming response patterns.
src/openai/resources/safety · high confidence
Added type definitions for Agent Vault credentials and authentication
The SDK now includes generated type definitions for managing credentials in the Agent Vaults beta API. This adds support for creating, listing, updating, and rotating credentials, including specific authentication methods like OAuth (with refresh token support), static bearer tokens, and environment variables for OpenAI-hosted environments. It also defines networking parameters to control which destinations can use these secrets.
src/openai/types/beta/agents/vaults · high confidence
Added type definitions for Realtime Translation client secrets
New Python type definitions have been added to support the Realtime Translation feature, specifically for creating client secrets. The \ClientSecretCreateParams\ TypedDict allows users to configure a \RealtimeTranslationSessionCreateRequestParam\ and set an expiration policy via \ExpiresAfter\. The expiration configuration supports an anchor point (currently only \created\_at\) and a duration in seconds (defaulting to 600 seconds, with a valid range of 10 to 7200 seconds), enabling controlled validity periods for secrets used to initiate translation sessions.
src/openai/types/realtime/translations · high confidence
Added type definitions for Vector Store file operations
New TypedDict and BaseModel classes have been added to the \src/openai/types/vector\_stores\ module to support file management within vector stores. This includes parameter types for creating (\FileCreateParams\), updating (\FileUpdateParams\), and listing (\FileListParams\) files, as well as batch operations (\FileBatchCreateParams\, \FileBatchListFilesParams\). The module also introduces \VectorStoreFile\, \VectorStoreFileBatch\, \VectorStoreFileDeleted\, and \FileContentResponse\ to represent the corresponding API resources and responses, enabling type-safe interaction with vector store file endpoints.
_src/openai/types/vector\stores · high confidence
Beta Agents API type definitions
The \src/openai/types/beta\ package now includes generated type definitions for the new Beta Agents API. This adds support for creating and managing reusable \Agent\ resources, handling \AgentSession\ events (including subagent coordination, tool results, and browser authentication), and configuring execution \Environment\ templates (network policies, packages, and files). Users can now interact with agent-specific parameters, tool configurations (MCP, web search, computer use), and session input/output types.
src/openai/types/beta · high confidence
Beta Agents SDK introduces typed streaming, local tool execution, and artifact handling
The \src/openai/lib/beta/agents\ module now provides a complete runtime layer for the Beta Agents API. Users can stream agent sessions with \AgentSessionEventStream\ and \AsyncAgentSessionEventStream\, which automatically collect and return typed final results via \get\_final\_result()\. The SDK supports local tool execution during session creation through \FunctionTool\ and helper factories like \pydantic\_function\_tool\, allowing developers to bind Pydantic models to synchronous or asynchronous callbacks with optional \defer\_loading\ for hosted tool search. Additionally, \AgentResultArtifacts\ enables users to look up, read, and download immutable artifacts (files) generated during a specific turn, while \agent\_text\_format\ and \with\_output\_schema\ facilitate strict JSON-schema validation for agent outputs.
src/openai/lib/beta · high confidence
Beta Realtime API type definitions added
The SDK now includes the complete set of type definitions for the OpenAI Realtime API under \src/openai/types/beta/realtime\. This adds support for configuring real-time audio sessions (including turn detection, audio formats, and voice selection), managing conversation history (creating, deleting, and truncating items), and handling streaming events (audio and text deltas, function call arguments). Users can now interact with the Realtime API using strongly typed parameters and response models.
src/openai/types/beta/realtime · high confidence
Expanded Admin API type definitions for organization management
The organization admin types module has been significantly expanded to support new administrative capabilities. This includes project residency configuration with support for multiple geographic regions (US, EU, JP, KR, CA, SG, IN, AU, GB, AE), external storage management for AWS, Azure, and GCP providers, and comprehensive spend controls with organization-level spend alerts and limits. The update also adds certificate lifecycle management (create, activate, deactivate, delete), enhanced audit logging with extensive event type filtering, and improved role-based access control for groups and users. Additionally, usage tracking has been expanded to include embeddings, audio (speeches and transcriptions), vector stores, web search calls, file search calls, and code interpreter sessions.
src/openai/types/admin/organization · high confidence
Expanded admin API types for project management
The SDK now includes generated type definitions for a broader set of project administration capabilities. Users can now type-check and interact with project-level spend controls (spend limits and email-based spend alerts), granular hosted tool permissions (code interpreter, file search, image generation, MCP, and web search), and model access policies (allow/deny lists). The update also adds support for managing project service accounts with configurable key expiration, updating API key scopes and expiry times, and handling data retention settings, alongside standard CRUD operations for project roles, users, and groups.
src/openai/types/admin/organization/projects · high confidence
Initial release of generated Beta Threads API types
This change introduces the complete set of generated Python type definitions for the OpenAI Beta Threads API, located in \src/openai/types/beta/threads\. It adds support for creating and managing threads, messages, and runs, including parameters for message content (text, image files, and image URLs), run execution (model selection, tool choices, temperature, and reasoning effort), and pagination/filtering (such as filtering messages by run ID). The types also cover streaming deltas for messages and tool calls, as well as specific tool integrations like file search and code interpreter.
src/openai/types/beta/threads · high confidence
Introduce Chat Completions storage and retrieval API
The chat completions resource now supports storing and retrieving conversation history. Users can enable persistence by passing \store=true\ when creating a completion, and subsequently fetch the individual messages from a stored completion via the new \client.chat.completions.messages.list()\ method (supporting pagination and ordering). This change also introduces a \parse()\ method on completions for automatic Pydantic model parsing and adds new parameters such as \prompt\_cache\_key\, \prompt\_cache\_retention\, \safety\_identifier\, and \verbosity\ to the completion creation interface.
src/openai/resources/chat/completions · high confidence
Introduce ChatKit beta resource with session and thread management
The SDK now exposes a new \ChatKit\ resource under \src/openai/resources/beta/chatkit\, providing both synchronous and asynchronous clients to manage ChatKit sessions and threads. Users can create, cancel, and inspect sessions, as well as list, retrieve, and delete threads and their items, with support for raw and streaming response accessors. This feature is gated by the \chatkit\_beta=v1\ header and relies on the \httpx2\ HTTP client.
src/openai/resources/beta/chatkit · high confidence
Introduce Conversations API resource with lazy loading
The \src/openai/resources/conversations\ module is now available, providing \Conversations\ and \Items\ classes that expose methods to create, retrieve, update, and delete conversations and their items. This implementation uses lazy loading via \\_\getattr\\_\ to avoid importing unrelated API resources on first use, and relies on the \httpx2\ HTTP client for network requests.
src/openai/resources/conversations · high confidence
Introduce Live API client support for real-time WebRTC and WebSocket sessions
The \src/openai/resources/live\ module now provides the client-side implementation for the Live API, enabling real-time, low-latency interactions. Users can create and manage Live WebRTC sessions via \client.live.create()\, and establish persistent WebSocket connections for streaming using \client.live.connect()\. The module also exposes sub-resources for managing session lifecycles (\sessions\), forking existing sessions (\forks\), and attaching to active sessions (\sideband\), along with the necessary type definitions and connection managers to handle real-time event streams.
src/openai/resources/live · high confidence
Introduce Live API with WebSocket lifecycle management and transcript grouping
This change introduces the Live API, providing a new \client.live\ interface for managing WebSocket connections and real-time transcripts. Users can now establish direct connections or sideband attachments to existing sessions, with explicit control over startup sequences (sending \session.start\ and waiting for \session.started\). The API includes \TranscriptGrouper\ and \AsyncTranscriptGrouper\ components for organizing transcript segments, and exposes specific types like \TranscriptSegment\ and \TranscriptSegmentClosedEvent\. The implementation preserves caller-configured queue sizes, handles reconnection via optional callbacks, and ensures that transport errors are reported directly to the caller rather than being silently absorbed, allowing applications to manage their own recovery and state reconstruction logic.
src/openai/lib/live · high confidence
Introduce Realtime API support with session and transcription session management
The SDK now exposes the Realtime API under the beta namespace, providing \Realtime\ and \AsyncRealtime\ resources that allow users to establish WebSocket connections for low-latency, multi-modal conversations. This update adds dedicated \Sessions\ and \TranscriptionSessions\ resources, enabling the creation of ephemeral API tokens and the configuration of session parameters such as model selection (e.g., \gpt-4o-realtime-preview\), audio formats, voice selection, and turn detection. The implementation leverages \httpx2\ for HTTP requests and integrates with the existing client architecture to support both synchronous and asynchronous usage patterns.
src/openai/resources/beta/realtime · high confidence
Introduce beta streaming helpers for OpenAI Agents
Added a new \src/openai/lib/streaming/agents\ module providing \AgentSessionStream\ and \AsyncAgentSessionStream\ classes to stream agent session turns and collect final typed outputs. This includes support for sequential tool handlers, idempotency key management for input submissions, and robust handling of tool call results and failures, enabling users to interact with the beta Agents API via a context-manager-based streaming interface.
src/openai/lib/streaming/agents · high confidence
Introduce structured streaming API for Chat Completions
Adds a new streaming module under \src/openai/lib/streaming/chat\ that wraps the raw Chat Completions stream to provide structured, event-driven processing. This includes \ChatCompletionStream\ and \AsyncChatCompletionStream\ classes that expose granular events (such as \ContentDeltaEvent\, \FunctionToolCallArgumentsDeltaEvent\, and \ContentDoneEvent\) and automatically accumulate a \ParsedChatCompletion\ object. The implementation supports automatic parsing of response content into specified types and handles tool call argument accumulation, making it easier for users to process streaming responses with structured data and tool usage.
src/openai/lib/streaming/chat · high confidence
New Admin API resource for organization management
The \src/openai/resources/admin\ package now exposes a comprehensive set of admin capabilities for managing organizations, including endpoints for audit logs, API keys, certificates, data retention, external storage, spend limits, and spend alerts. This addition allows administrators to programmatically control organization-level settings, monitor activity, and manage security configurations directly through the SDK.
src/openai/resources/admin · high confidence
New Alpha Fine-Tuning Graders API support
The SDK now exposes the alpha fine-tuning graders API, allowing you to validate and run custom graders for fine-tuning jobs. This change adds the \openai.fine\_tuning.alpha\ resource module, which includes \Alpha\ and \Graders\ classes (with async and streaming variants) to interact with the \/fine\_tuning/alpha/graders/run\ and \/fine\_tuning/alpha/graders/validate\ endpoints.
_src/openai/resources/fine\tuning/alpha · high confidence
New Beta API resources for Agents, Responses, and ChatKit
The \src/openai/resources/beta\ module now exposes dedicated resource classes for the Agents API, the new Responses API, and the ChatKit, alongside the existing Assistants and Threads resources. Users can now access these capabilities via \client.beta.agents\, \client.beta.responses\, and \client.beta.chatkit\, with full support for both synchronous and asynchronous operations, as well as raw and streaming response wrappers.
src/openai/resources/beta · high confidence
New Beta Agents Sessions API client resources
The SDK now includes a complete set of client resources for the Beta Agents Sessions API under \src/openai/resources/beta/agents/sessions\. This adds support for managing agent sessions, including creating and streaming sessions, submitting and streaming events, listing and retrieving items and turns, managing subagents, and handling session artifacts and traces. Both synchronous and asynchronous clients are provided, along with raw response and streaming response wrappers for all resources.
src/openai/resources/beta/agents/sessions · high confidence
New Beta Responses API resource with input item and token counting support
The SDK now exposes a dedicated \beta.responses\ resource for creating and managing model responses. This addition includes sub-resources for listing input items (\input\_items\) and calculating input token usage (\input\_tokens\), alongside the main \responses\ resource for creating, retrieving, and streaming responses. The implementation supports both synchronous and asynchronous clients, provides raw and streaming response accessors, and integrates with the updated HTTPX2 transport layer.
src/openai/resources/beta/responses · high confidence
New Checkpoints and Permissions API for Fine-Tuning
The SDK now exposes a new \fine\_tuning.checkpoints\ resource, allowing users to manage permissions for fine-tuned model checkpoints. This includes listing, creating, and retrieving permissions to share checkpoints with specific projects, requiring an admin API key. The implementation introduces lazy loading for these resources and supports both synchronous and asynchronous clients, along with raw and streaming response accessors.
_src/openai/resources/fine\tuning/checkpoints · high confidence
New Container Files API resource
Added a new \files\ resource under the containers API, enabling users to create, list, and retrieve container files, as well as access their raw content via binary responses. This includes both synchronous and asynchronous client support, with options for raw response access and streaming.
src/openai/resources/containers/files · high confidence
New Evals API grader types and parameters
The SDK now includes generated type definitions for the Evals API graders, enabling users to construct evaluation requests. This adds support for five grader types: StringCheck (comparing input to reference using operations like eq, ne, like, ilike), TextSimilarity (using metrics such as cosine, bleu, rouge, etc.), Python (executing a custom Python script), ScoreModel (using a model to assign a numeric score with configurable sampling parameters), and LabelModel (using a model to assign categorical labels). It also introduces MultiGrader for combining multiple graders via a calculation formula, and GraderInputs to define flexible input content including text, images, and audio.
src/openai/types/graders · high confidence
New Evals API resource for managing model evaluations
The SDK now includes a new \Evals\ resource under \src/openai/resources/evals\, allowing users to create, retrieve, update, and delete evaluations to test model performance. This addition exposes the underlying API endpoints for defining evaluation criteria and data sources, enabling programmatic management of model quality assessments.
src/openai/resources/evals · high confidence
New Evals API type definitions for run and output management
The SDK now includes generated type definitions for the Evals API in \src/openai/types/evals\, enabling users to configure and manage evaluation runs. This adds parameter types for creating runs from JSONL files or stored completions, listing and filtering runs by status, and retrieving paginated output items with pass/fail status. These types support the underlying API calls for setting up and monitoring model evaluations.
src/openai/types/evals · high confidence
New Realtime API resource with calls, translations, and client secrets
The SDK now exposes a dedicated \realtime\ resource under \src/openai/resources/realtime\, providing first-class support for the Realtime API. This includes a \Realtime\ class with a \connect()\ method for establishing WebSocket sessions, a \Calls\ resource for managing WebRTC call lifecycle (create, accept, hangup, refer, reject), a \Translations\ resource for streaming audio translations, and \ClientSecrets\ resources for generating short-lived, scoped tokens for both general Realtime and Translation sessions. The module also exports a comprehensive set of Pydantic types for Realtime events, session configurations, and parameters.
src/openai/resources/realtime · high confidence
New Realtime API type definitions for sessions, calls, and events
The \src/openai/types/realtime\ module now exposes a comprehensive set of generated type definitions for the Realtime API. This includes parameter models for creating and managing Realtime sessions and SIP calls (e.g., \CallAcceptParams\, \CallCreateParams\), configuration for audio input/output (including noise reduction, turn detection, and custom voices), and event types for conversation items, audio buffers, and MCP tool interactions. Users can now leverage these types for strict type-checking when building Realtime and telephony integrations.
src/openai/types/realtime · high confidence
New Responses API examples for streaming, background processing, and multi-agent workflows
The \examples/responses\ directory now includes a comprehensive set of demonstration scripts for the new Responses API. These examples cover synchronous and asynchronous streaming, background execution with resume capabilities, structured output parsing using Pydantic models, and tool calling integration. Additionally, new WebSocket-based examples demonstrate real-time interaction, including a multi-agent streaming demo and a complex multi-turn tool-use scenario, providing users with reference implementations for these advanced capabilities.
examples/responses · high confidence
New Responses API resource with input items, token counting, and compaction
The \src/openai/resources/responses\ directory now exposes a dedicated Responses API resource, providing \create\, \retrieve\, \delete\, \cancel\, and \compact\ methods for managing model responses. It also introduces \input\_items\ for listing response inputs and \input\_tokens\ for calculating token usage. The implementation supports both synchronous and asynchronous clients, including raw and streaming response accessors, and integrates with the new HTTPX2 client for underlying network operations.
src/openai/resources/responses · high confidence
New Responses API type definitions for tools, actions, and containers
The SDK now includes generated type definitions for the Responses API, enabling support for new capabilities. This adds types for the Computer tool and its associated actions (click, drag, type, screenshot, etc.), as well as the ApplyPatch tool for file modifications. It also introduces container support with auto-provisioning, network policies, and skills, alongside updates to the FileSearch tool with hybrid search ranking options and new message input types like EasyInputMessage with phase support.
src/openai/types/responses · high confidence
New SDK examples for modern features and authentication
The examples directory now includes comprehensive demonstrations for recently added SDK capabilities. Users can explore new API endpoints such as the Responses API (including input token counting and WebSocket sessions), Amazon Bedrock provider support, and the deprecated Sora video API. The collection also covers new audio helpers (text-to-speech, transcription, translation), image streaming with partial images, and chunked file uploads. Additionally, new examples illustrate advanced authentication methods, including Azure AD token providers, mutual TLS (mTLS) with both httpx and httpx2 clients, and X.509 workload identity federation.
examples · high confidence
New SDK library utilities for Azure, Bedrock, and structured outputs
The \src/openai/lib\ package now provides a set of helper modules to extend the SDK's capabilities. This includes \azure.py\ for managing Azure OpenAI authentication and endpoint routing, \\_bedrock\_auth.py\ for AWS Bedrock SigV4 signing, and \\_tools.py\ alongside \\_pydantic.py\ to facilitate structured outputs via Pydantic model conversion. Additionally, the library introduces \\_webhooks.py\ for signature verification, \\_websocket.py\ and \\_azure\_websocket.py\ for secure WebSocket handling, and polling helpers in \\_files.py\ and \\_vector\_stores.py\ for file and vector-store operations.
src/openai/lib · high confidence
New Uploads API for chunked file uploads
The library now exposes a dedicated \uploads\ resource that enables uploading large files (up to 8 GB) in multiple parts. This includes a high-level \upload\_file\_chunked\ helper that automatically splits files into 64 MB chunks and uploads them sequentially, as well as lower-level \create\, \parts.create\, and \complete\ methods for manual chunk management. The implementation supports both file paths and in-memory bytes, handles multipart form data, and provides both synchronous and asynchronous client interfaces.
src/openai/resources/uploads · high confidence
New Webhooks resource for endpoint management and event subscriptions
The SDK now includes a dedicated \webhooks\ resource that allows you to manage webhook endpoints and subscribe to specific event types. You can create, retrieve, update, list, and delete webhook endpoints via the \client.webhooks\ interface, and test deliveries or rotate secrets for existing endpoints. The resource exposes a comprehensive set of webhook event types—including batch, response, fine-tuning, agent session, safety, and realtime events—enabling your application to react to these lifecycle changes.
src/openai/resources/webhooks · high confidence
New beta API for managing hosted agent environments, templates, and files
The SDK now exposes a new \beta.agents.environments\ resource group that allows users to create, list, and retrieve prewarmed hosted execution environments, manage reusable environment templates (including configuration for packages, plugins, skills, and network policies), and stage files into those environments. This enables users to provision and configure isolated execution contexts for agents before running sessions.
src/openai/resources/beta/agents/environments · high confidence
New beta Agents Vaults and Credentials API resources
This change introduces the \src/openai/resources/beta/agents/vaults\ module, exposing new client-side resources for managing Agent Vaults and their Credentials. Users can now create, retrieve, list, and update Vaults, as well as create, retrieve, update, and list Credentials within those Vaults. The implementation includes both synchronous and asynchronous client classes, with support for raw and streaming HTTP responses, allowing developers to integrate secret storage and credential management directly into their Agent workflows.
src/openai/resources/beta/agents/vaults · high confidence
New browser-use demo and read-only browser examples
Added a new browser-use demo in examples/browser-use-demo that provides a local operator dashboard (Fieldwork) for booking a table in a synthetic browser, including a custom BookingBrowser driver, a reservation fixture, and exercise scripts to test live and rehearsal modes. Also added a read-only browser example in examples/browser that demonstrates reading local pages and answering questions using the browser toolset, along with its own exercise script and documentation.
examples/browser · high confidence
New evals runs API resource for managing evaluation runs and output items
The SDK now includes a new \evals.runs\ resource that exposes methods to manage evaluation runs and their output items. Users can create, list, retrieve, and cancel runs for a specific evaluation, as well as list and retrieve individual output items generated by those runs. This resource supports both synchronous and asynchronous clients, with options for raw and streaming responses, and integrates with the existing pagination and request options infrastructure.
src/openai/resources/evals/runs · high confidence
New fine-tuning jobs and checkpoints API resources
The SDK now exposes dedicated resources for managing fine-tuning jobs and their checkpoints under the \openai.fine\_tuning.jobs\ namespace. Users can create, list, and retrieve fine-tuning jobs, as well as list checkpoints for a specific job, using both synchronous and asynchronous clients. The implementation supports raw and streaming response accessors for these resources, and the job creation API includes parameters for model selection, training/validation files, hyperparameters, integrations, metadata, and method-specific settings.
_src/openai/resources/fine\tuning/jobs · high confidence
New fine-tuning methods and parameters added to the API types
The fine-tuning type definitions have been expanded to support new training approaches. Users can now configure Direct Preference Optimization (DPO) and reinforcement learning fine-tuning jobs, with specific parameter classes for their respective hyperparameters (such as beta for DPO and reasoning effort for reinforcement learning). The job creation parameters now use a unified 'method' field to select between supervised, DPO, and reinforcement methods, replacing the older standalone hyperparameters structure. Additionally, support for Weights & Biases (WandB) integrations has been added to track job metrics.
_src/openai/types/fine\tuning · high confidence
New fine-tuning resource structure with raw and streaming response support
The fine-tuning resource module has been restructured to expose a comprehensive API surface for managing fine-tuning jobs, checkpoints, and alpha features. This change introduces dedicated resource classes for both synchronous and asynchronous usage, each providing access to sub-resources for jobs, checkpoints, and alpha endpoints. Additionally, the module now supports raw response access (returning the raw HTTP response object) and streaming response handling (avoiding eager body reads) for all fine-tuning operations, allowing users to inspect headers or process large responses more efficiently.
_src/openai/resources/fine\tuning · high confidence
New generated types for organization and project role management
The SDK now includes generated type definitions for managing role assignments at both the organization and project levels. New classes such as RoleCreateParams, RoleListParams, RoleCreateResponse, and RoleDeleteResponse are available under src/openai/types/admin/organization/users and src/openai/types/admin/organization/projects/users and groups, enabling developers to programmatically list, create, and delete role assignments for users and groups within organizations and specific projects.
src/openai/types/admin/organization/projects/groups, src/openai/types/admin/organization/projects/users, src/openai/types/admin/organization/users · high confidence
New safety case and alert types exposed in the API client
The library now exposes SafetyCase and SafetyAlert types in the safety module, allowing users to interact with safety case retrieval and alert data returned by the API.
src/openai/types/safety · high confidence
New streaming helpers for Assistant API events
Added a new \src/openai/lib/streaming\ module providing \AssistantEventHandler\, \AsyncAssistantEventHandler\, and their manager counterparts to simplify consuming Assistant API streaming responses. These classes expose convenient properties like \text\_deltas\ for iterating over text chunks and callbacks for run steps and messages, while internally using a new \accumulate\_delta\ utility to correctly merge stream deltas, including handling indexed tool calls.
src/openai/lib/streaming · high confidence
New streaming responses API with typed parsing and tool support
This change introduces a new \src/openai/lib/streaming/responses\ module that provides \ResponseStream\ and \AsyncResponseStream\ classes for handling the new \/v1/responses\ API. These streams support generic text parsing via a \text\_format\ parameter, allowing users to receive structured output directly in \ResponseTextDoneEvent\ and \ResponseCompletedEvent\. The implementation also includes support for \input\_tools\, enabling the use of built-in and custom tools within the streaming context, and exposes a comprehensive set of event types (including MCP, shell, and image generation events) for detailed stream monitoring.
src/openai/lib/streaming/responses · high confidence
New structured parsing library for chat completions, responses, audio, and embeddings
The SDK now includes a new \src/openai/lib/\_parsing\ module that provides automatic parsing capabilities for API responses. For chat completions, it enables auto-parsing of function tool arguments and message content into Pydantic models or dataclasses, supporting strict function tools. For the new Responses API, it parses text outputs and function call arguments based on specified text formats, while explicitly skipping non-text output types. Audio transcription and translation responses are automatically parsed into the correct verbose or diarized types based on the requested format. Embedding responses are automatically converted from base64-encoded strings to float arrays, optimizing performance with NumPy when available.
_src/openai/lib/\parsing · high confidence
New type definitions for OpenAI Agents beta API
The SDK now includes generated type definitions for the OpenAI Agents beta API, enabling users to configure and manage agents, sessions, environments, and vaults. This adds support for creating and listing OpenAI-hosted environments with network policies, desktop provisioning, and package installation. Users can now create and update agent sessions with spending limits, streaming options, and model settings including the new 'ultrafast' service tier. The update also introduces vault management capabilities for storing credentials, with filtering by status and metadata.
src/openai/types/beta/agents, src/openai/types/conversations · high confidence
New webhook endpoint management and event types
The SDK now includes generated types for managing webhook endpoints, allowing users to create, list, update, and test webhooks. This update introduces support for a wide range of webhook event types, including batch operations (completed, failed, expired, cancelled), responses (completed, failed, cancelled, incomplete), evaluations (succeeded, failed, canceled), fine-tuning jobs (succeeded, failed, cancelled), real-time calls, video processing, and agent sessions (created, in\_progress, idle, failed, action\_required). Additionally, new safety-related event types are available, such as safety alerts, warnings, deactivations, and identifier blocks, enabling users to monitor and react to safety events via webhooks.
src/openai/types/webhooks · high confidence
SDK restructured into modular resource files with new API capabilities
The \src/openai/resources\ directory has been reorganized from a single monolithic file into individual modules for each API area (e.g., \batches.py\, \embeddings.py\, \files.py\, \images.py\, \content\_provenance\_checks.py\). This change introduces support for new API features including the Batch API, Content Provenance Checks, and file expiration policies, while also migrating the underlying HTTP client to \httpx2\.
src/openai/resources · high confidence
Service account API keys now support expiration
The API for creating service account API keys now accepts an optional \expires\_in\_seconds\ parameter to define how long the key remains valid. The creation response includes a new \expires\_at\ field indicating the specific Unix timestamp when the key will expire, or null if the key is set to never expire.
_src/openai/types/admin/organization/projects/service\accounts · high confidence
Structured output parsing examples and internal model/provider infrastructure updates
The SDK now includes new examples in the \examples/\ directory demonstrating how to use the \client.chat.completions.parse()\ method for structured output with Pydantic models, including both standard and streaming modes, as well as tool-use scenarios with \pydantic\_function\_tool\. Internally, the SDK has been refactored to support a new provider architecture (\\_provider.py\, \lib/bedrock.py\) and updated model handling (\\_models.py\) to better support these parsing features and other API changes.
openai · high confidence
Vector Stores API implementation with file and batch management
The \src/openai/resources/vector\_stores\ module now provides the client-side implementation for the Vector Stores API, enabling users to create, retrieve, update, and delete vector stores, as well as manage files and file batches within them. This includes support for chunking strategies, metadata attributes, and expiration policies on stores, while file operations allow attaching files to stores and batch-ingest multiple files at once. The implementation uses the \httpx2\ HTTP client and exposes synchronous and asynchronous resource classes with raw and streaming response options.
_src/openai/resources/vector\stores · high confidence
Removals
Removal of client-side semantic search example
The client-side semantic search example script and its documentation have been removed from the repository. This example previously demonstrated how to perform semantic search locally by formatting documents into prompts and post-processing logprobs to derive relevance scores, a method the documentation noted was less optimal than the server-side implementation for latency-sensitive workloads.
examples/semanticsearch · high confidence
Removal of legacy CLI entry point
The \bin/openai\ script, which previously served as the command-line interface for the OpenAI Python client, has been removed. Users relying on this specific executable to interact with the API via the command line will no longer have access to this entry point.
bin · high confidence
Removal of public PyPI placeholder package infrastructure
The build and packaging infrastructure for the public PyPI placeholder package has been removed. Specifically, the \Makefile\ containing build and upload targets and the \setup.py\ script that enforced the \OPENAI\_UPLOAD\ environment variable check have been deleted. This eliminates the ability to build or upload this specific placeholder distribution via the previous methods.
public · high confidence
Behavioural changes
1 commit (0 fixes) modifying src/openai/resources/beta/agents/automations, src/openai/types/beta/agents/automations
A change to existing behaviour in src/openai/resources/beta/agents/automations, src/openai/types/beta/agents/automations — 1 commit, 5 files: “feat(api): add delegation controls and prompt cache lifetimes (\#4169)” (refs \#4169).
src/openai/resources/beta/agents/automations, src/openai/types/beta/agents/automations · medium confidence · unverified
10 commits (0 fixes) modifying src/openai/types/live
A change to existing behaviour in src/openai/types/live — 10 commits, 63 files: “feat(api) Add Live API (\#3846)”; “feat(api): expand Decisions input and question types (\#4158)”; “feat(api): support Decisions in Live sessions (\#4088)”; and 7 more (refs \#3846, \#4158, \#4088, \#4087, \#4169, …).
src/openai/types/live · medium confidence · unverified
12 commits (3 fixes) modifying src/openai/resources/beta/agents
A change to existing behaviour in src/openai/resources/beta/agents — 12 commits (3 fixs), 2 files: “chore(api): clarify agent tool limits and environment pagination (\#4065)”; “feat(api): add ultrafast service tier for Agents (\#4101)”; “feat(api): add experimental agent time awareness (\#4211)”; and 9 more (refs \#4065, \#4101, \#4211, \#3847, \#4169, …).
src/openai/resources/beta/agents · medium confidence · unverified
14 commits (3 fixes) modifying examples/realtime
A change to existing behaviour in examples/realtime — 14 commits (3 fixs), 5 files: “docs(examples): fix two stale example comments (\#3877)”; “fix(examples): handle interruptions and disconnects in push-to-talk (\#4192)”; “feat(api): realtime API updates”; and 11 more (refs \#3877, \#4192, \#4202, \#4210, \#1967, …).
examples/realtime · medium confidence · unverified
2 commits (0 fixes) modifying examples/browser-use-demo, examples/computer-desktop, scripts/fixtures
A change to existing behaviour in examples/browser-use-demo, examples/computer-desktop, scripts/fixtures — 2 commits, 34 files: “chore: migrate development type checking to ty (\#4202)”; “feat: add browser and computer toolsets (1/4) (\#4073)” (refs \#4202, \#4073).
examples/browser-use-demo, examples/computer-desktop, scripts/fixtures · medium confidence · unverified
2 commits (0 fixes) modifying src/openai/providers
A change to existing behaviour in src/openai/providers — 2 commits, 1 file: “feat: add Vertex AI support for the Responses API (\#4139)”; “\[codex\] Add AWS Bedrock provider authentication (\#3398)” (refs \#4139, \#3398).
src/openai/providers · medium confidence · unverified
2 commits (1 fix) modifying examples/live
A change to existing behaviour in examples/live — 2 commits (1 fix), 3 files: “feat(api) Add Live API (\#3846)”; “fix(examples): detect incomplete WebSocket responses (\#4187)” (refs \#3846, \#4187).
examples/live · medium confidence · unverified
Audio resource module restructured with new submodules and lazy loading
The audio resource package has been reorganized into dedicated submodules for transcriptions, translations, speech, and voices, each exposing sync, async, raw-response, and streaming variants. The main audio module now uses lazy loading via \_\getattr\\_ to import these submodules and resource classes on demand, improving startup performance. The speech submodule now supports additional response formats (mp3, opus, aac, flac, wav, pcm) and streaming formats (sse, audio), while the voices submodule adds support for creating custom voices from text prompts or audio samples with consent recordings.
src/openai/resources/audio · high confidence
Chat API types updated for new model features and custom tools
The chat completion parameter types have been updated to support new API capabilities, including custom tools (with grammar and text formats), predicted outputs for faster regeneration, and prompt cache breakpoints for efficient caching. The message role type now includes 'developer' to replace 'system' for newer models, and the tool choice options have been expanded to support named custom tools and allowed tool sets. Audio output parameters now support custom voices, and streaming options include usage tracking and obfuscation controls.
src/openai/types/chat · high confidence
Internal utility module restructuring and new helper functions
The internal \src/openai/\_utils\ package has been restructured into a modular layout with dedicated files for specific concerns, including \\_datetime\_parse\ for date/time handling, \\_json\ for custom JSON serialization, \\_logs\ for logging configuration and sensitive header redaction, \\_path\ for URI path interpolation and validation, \\_proxy\ for lazy loading proxies, \\_reflection\ for function signature inspection, \\_streams\ for iterator consumption, \\_sync\ for async/sync bridging, \\_transform\ for data transformation based on type annotations, \\_typing\ for type introspection, and \\_utils\ for general utilities. This change introduces new public exports such as \SensitiveHeadersFilter\ for redacting sensitive headers in logs, \path\_template\ for safe URI path construction, \asyncify\ for converting blocking functions to async, and various type-checking helpers like \is\_list\_type\ and \is\_annotated\type\. The \\\init\\_.py\ file now serves as a central re-export hub for these new modules.
_src/openai/\utils · high confidence
Introduce lazy loading for the Threads API resource module
The \src/openai/resources/beta/threads/\_\init\\_.py\ module now uses lazy loading for its submodules (Threads, Messages, Runs) and their associated response wrappers. This means the heavy imports for these specific API resources are deferred until they are actually accessed, rather than being loaded immediately when the parent package is imported. This change improves initial import performance and reduces memory overhead for users who do not interact with the Threads API.
src/openai/resources/beta/threads · high confidence
Introduce lazy loading for the Threads Runs resource module
The \src/openai/resources/beta/threads/runs/\_\init\\.py\ module now uses lazy loading via \\\getattr\\\ and \\\dir\\_\ to import the \Runs\, \Steps\, and their async/raw/streaming variants only when accessed. This reduces startup overhead and memory usage by deferring the import of the heavy \runs.py\ and \steps.py\ implementation files until the user actually interacts with the runs or steps API resources.
src/openai/resources/beta/threads/runs · high confidence
Lazy loading of chat resource classes
The chat resource module now uses lazy loading for its classes (Chat, AsyncChat, and their raw/streaming variants) via \_\getattr\\_ and cached\_property. This means the chat-related API resources are no longer imported and initialized at startup, reducing initial import overhead and memory usage when the chat functionality is not immediately needed.
src/openai/resources/chat · high confidence
Lazy-loading for optional audio and data dependencies
The library now uses lazy proxies for optional dependencies like numpy, pandas, and sounddevice. This means these packages are no longer required at import time; they are only loaded when actually used. If a user attempts to use a feature requiring one of these libraries without having it installed, they will receive a clear error message instructing them to install the specific extra (e.g., \openai\[voice\_helpers\]\ or \openai\[datalib\]\). This improves installation speed and reduces overhead for users who do not need audio or data processing features.
_src/openai/\extras · high confidence
Migrated development tooling to uv and Steady
The repository's development workflow has been updated to use the uv package manager for Python dependency resolution and the Steady mock server for API testing. The new bootstrap script installs Python dependencies via uv and Node tooling via pnpm, while the test suite now automatically starts a Steady server to validate against the local OpenAPI specification. Additionally, a new Python version policy checker ensures consistency across the codebase, and breaking change detection now utilizes Steady for more robust local API reference testing.
scripts · high confidence
Migrated to a forked Steady tool with pinned Deno runtime
The development environment now uses a self-contained, pinned version of the Steady tooling sourced from a forked repository (openai-oss-forks/steady) rather than the upstream. This change introduces a new installation workflow under scripts/steady that downloads and verifies a specific Deno runtime (v2.7.11) alongside the Steady source code, ensuring reproducible builds through strict SHA-256 checksums for both the runtime and the source. The system includes integrity verification to prevent execution of modified or cached Git hooks, and provides scripts to update the pinned revision and verify the installation locally.
scripts/steady · high confidence
New validation and tooling scripts for SDK release artifacts
Added a suite of utility scripts in \scripts/utils\ to enforce quality and compatibility standards for SDK distribution packages. \validate-httpx2-wheel.py\ verifies that wheels correctly require the new HTTPX2 client, exclude the legacy HTTPX package, and pass integration tests for base, aiohttp, and legacy compatibility modes. \validate-bedrock-wheel.py\ ensures the Bedrock provider is packaged without the heavy \botocore\ dependency and that TLS hostname configuration is preserved. \validate-python-version-wheel.py\ confirms that the \Requires-Python\ metadata is set to \\>=3.10\ and that Python 3.9 interpreters correctly reject the wheel. Additionally, \node-tooling.cjs\ locks the repository's Pyright toolchain to a specific local version, and \ruffen-docs.py\ provides a fork of \blacken-docs\ adapted to use Ruff for formatting Python code blocks in documentation.
scripts/utils · high confidence
Release 3.24.0 with custom-code budget enforcement and Python 3.10 minimum
This release introduces a custom-code budget ceiling (10,000 lines) enforced via \.castiron-ratchet.json\ to limit handwritten SDK patches, and raises the minimum supported Python version to 3.10 (\.python-version\ set to 3.10.16, \requires-python\ updated). It also adds the \FilePurpose\ enum type and updates the release manifest to 3.24.0.
(repo-wide) · high confidence
SDK rewritten to use httpx2 with new client architecture and data residency support
The OpenAI Python SDK has been rebuilt from the ground up, replacing the legacy httpx dependency with httpx2 for all HTTP operations. This introduces a new client architecture (including \DefaultHttpx2Client\ and \DefaultAsyncHttpx2Client\) and adds support for named data-residency endpoints (global, us, eu, ae) via a dedicated \data\_residency\ argument. The change also brings Pydantic v2/v3 compatibility layers, lazy loading for resource modules to improve startup performance, and new authentication features like X.509 workload identity federation and admin API key support.
src/openai · high confidence
SDK types updated to reflect latest OpenAPI spec
The type definitions in src/openai/types have been regenerated from the OpenAPI specification, introducing support for new API capabilities. This includes new model enums for Audio (e.g., gpt-4o-transcribe-diarize), Embedding, and Chat models, as well as new parameter types for Batch API (with /v1/videos endpoint support), Container management, and Evaluation workflows. Additionally, file handling types now include the 'evals' purpose, and audio response formats now support 'diarized\_json'.
src/openai/types · high confidence
Updated audio API type definitions with new models and diarization support
The audio type definitions have been refreshed to reflect the latest API capabilities. Transcription now supports the \gpt-4o-transcribe-diarize\ model, which enables speaker diarization (identifying different speakers) and requires specific chunking strategies for long audio. New TTS models (\gpt-4o-mini-tts\) and custom voice creation parameters are included, along with expanded response formats and streaming event types for transcriptions.
src/openai/types/audio · high confidence
Updated model identifiers and API type definitions
The shared parameter types have been updated to include new model identifiers such as the GPT-6 family (e.g., gpt-6-astra, gpt-6.1-sol), GPT-5.6 variants, and new Responses models like o1-pro, o3-pro, and gpt-5-codex. The ChatModel type now includes deprecation notices for several older models. Additionally, the ComparisonFilter type has been extended to support 'in' and 'nin' operators, and the FunctionDefinition type now includes a 'strict' parameter for structured outputs.
_src/openai/types/shared\params · high confidence
Updated model identifiers and shared type definitions
The shared types module has been regenerated to include new model identifiers for the GPT-5, GPT-6, and o-series families (such as gpt-5.5-pro, gpt-6-astra, o3-pro, and o4-mini-deep-research) in the ChatModel and ResponsesModel type aliases. Additionally, the module now exposes new type definitions for Responses-specific models, reasoning effort levels, and function definitions, while also documenting announced deprecation dates for several legacy model IDs.
src/openai/types/shared · high confidence
Vendor HTTPX2-compatible aiohttp adapter to support older aiohttp versions
The SDK now includes a vendored copy of the httpx-aiohttp adapter (from version 0.2.0) specifically modified to work with HTTPX2. This change allows the \openai\[aiohttp\]\ optional integration to function correctly with older aiohttp installations (pre-3.10) by gracefully handling missing exception exports like \SocketTimeoutError\, ensuring the SDK falls back to its default HTTPX2 clients rather than failing to import.
_src/openai/\vendor · high confidence
Test coverage
11 commits adding/updating tests in tests/lib/live; 14 commits adding/updating tests in tests/api\_resources/beta/agents; 9 commits adding/updating tests in tests/lib/streaming; Added comprehensive test coverage for Responses API edge cases and WebSocket handling; Added comprehensive test coverage for SDK utility functions; Added generated tests for Vector Store files and file batches; Added generated tests for audio API resources; Added generated tests for chat completions and stored messages; Added generated tests for new API resources; Added test for ChatCompletionToolParam instantiation; Added test suite for Live API sessions and AWS Bedrock authentication; Added tests for Realtime API calls and client secrets; Added tests for Realtime translations client secrets; Added tests for Responses API input items and input tokens; Added tests for admin organization groups, projects, and service accounts; Added tests for alpha fine-tuning grader API; Added tests for beta agent tool integration; Added tests for beta agents environments files and templates; Added tests for beta agents sessions resources; Added tests for beta agents vaults credentials API; Added tests for beta threads, messages, runs, and run steps; Added tests for chat completions parsing, streaming, and tool handling; Added tests for conversations items API; Added tests for fine-tuning checkpoint permissions; Added tests for fine-tuning jobs and checkpoints; Added tests for safety alerts and cases retrieval; Added tests for webhook event type listing; Expanded test coverage for Azure authentication, Bedrock live integration, and audio response formats; Updated test snapshots for structured outputs and refusal handling.
Dependencies
SDK 3.24.0 release with HTTPX2 migration and Python 3.14 support
The openai Python SDK has been updated to version 3.24.0, introducing a migration to the HTTPX2 client library (httpx2\>=2.12.0) for network requests. This release requires Python 3.10 or higher and adds explicit support for Python 3.14 by bumping the jiter dependency to \>=0.16.0. The package now uses the uv tool for dependency management and includes updated dev tooling, such as mypy 2.3.1 and pyright 1.1.414, alongside security constraint dependencies for transitive packages like cryptography and requests.
(dependencies) · high confidence
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 62 → 62 (-0.3)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.1) — scores are not directly comparable.
Lenses
- Code Health 57 → 57 (+0.0)
- Architecture 89 → 91 (+1.1)
- Maturity 65 → 69 (+4.2)
- Readiness 75 → 67 (-8.3)
- Security 83 → 79 (-3.9)
- Performance 60 → 60 (+0.0)
Resolved (148)
- AsyncOpenAI.init (cognitive 53) (src/openai/_client.py)
- AsyncOpenAI.init (cyclomatic 43) (src/openai/_client.py)
- AsyncOpenAI._send_with_auth_retry (cognitive 19) (src/openai/_client.py)
- AsyncOpenAI.copy (cognitive 57) (src/openai/_client.py)
- AsyncOpenAI.copy (cyclomatic 55) (src/openai/_client.py)
- AsyncResponses.stream (cognitive 23) (src/openai/resources/responses/responses.py)
- AsyncUploads.upload_file_chunked (cognitive 25) (src/openai/resources/uploads/uploads.py)
- Documentation: no architecture or design documentation (README.md)
- Duplicated block (10 lines × 14) (src/openai/resources/beta/responses/responses.py)
- Duplicated block (10 lines × 14) (src/openai/resources/beta/responses/responses.py)
- Duplicated block (10 lines × 2) (src/openai/_client.py)
- Duplicated block (10 lines × 2) (src/openai/lib/responses_websocket/_session.py)
- Duplicated block (10 lines × 2) (src/openai/resources/realtime/translations/translations.py)
- Duplicated block (10–11 lines × 2) (src/openai/resources/responses/responses.py)
- Duplicated block (11 lines × 14) (src/openai/resources/beta/responses/responses.py)
- Duplicated block (11 lines × 2) (src/openai/_client.py)
- Duplicated block (11–13 lines × 7) (src/openai/resources/beta/responses/responses.py)
- Duplicated block (11–13 lines × 7) (src/openai/resources/beta/responses/responses.py)
- Duplicated block (12 lines × 2) (src/openai/resources/embeddings.py)
- Duplicated block (120–121 lines × 2) (src/openai/_client.py)
- …and 128 more
New (303)
- AgentTurnResultCollector.accept (cognitive 29) (src/openai/lib/beta/agents/_result.py)
- AsyncAzureOpenAI._prepare_options (cognitive 16) (src/openai/lib/azure.py)
- AsyncForksConnection.aiter (cognitive 17) (src/openai/resources/live/forks.py)
- AsyncLiveConnection.aiter (cognitive 17) (src/openai/resources/live/live.py)
- AsyncRealtimeConnection.aiter (cognitive 17) (src/openai/resources/realtime/realtime.py)
- AsyncRealtimeConnectionManager._connect_ws (cognitive 19) (src/openai/resources/realtime/realtime.py)
- AsyncResponsesWebSocketSession._read (cognitive 16) (src/openai/lib/responses_websocket/_session.py)
- AsyncSidebandConnection.aiter (cognitive 17) (src/openai/resources/live/sideband.py)
- AsyncTranslationsConnection.aiter (cognitive 17) (src/openai/resources/realtime/translations/translations.py)
- AsyncWebSocketConnectionBase._attempt_reconnect (cyclomatic 17) (src/openai/_websocket_connection.py)
- AsyncWebSocketConnectionBase._iter_events (cognitive 17) (src/openai/_websocket_connection.py)
- AzureOpenAI._prepare_options (cognitive 16) (src/openai/lib/azure.py)
- Change coupling: file_batches.py ↔ files.py (src/openai/resources/vector_stores/file_batches.py)
- Change coupling: forks.py ↔ sideband.py (src/openai/resources/live/forks.py)
- Change-coupling hub: realtime.py → forks.py, live.py, sideband.py (src/openai/resources/realtime/realtime.py)
- Change-coupling hub: response_compact_params.py → beta_responses_client_event.py, beta_responses_client_event_param.py, chat_model.py, chat_model.py (src/openai/types/beta/response_compact_params.py)
- Critical CVE: [GHSA redacted] (uv.lock)
- Critical vulnerability: [GHSA redacted] (uv.lock)
- Duplicated block (10 lines × 10) (src/openai/resources/live/forks.py)
- Duplicated block (10 lines × 10) (src/openai/resources/live/forks.py)
- …and 283 more
Changes since last survey
- 91 commits — 68 feature/other, 23 fixes
By area
- src/openai — 46 commits
- (root) — 17 commits
- .github/workflows — 11 commits
- scripts/castiron — 5 commits
- tests/lib — 5 commits
- examples/realtime — 3 commits
- docs/castiron-generated-code-transition.md — 1 commit
- docs/castiron-polling-runtime-preparation.md — 1 commit
- scripts/detect-breaking-changes — 1 commit
- tests/test_client.py — 1 commit
Notable commits
- fix: Fix Realtime example keepalive while awaiting input (#4207)
- fix: Refresh Castiron transition plan and fix translation test startup race (#4141)
- fix: fix(agents): clarify result schema warnings (#4165)
- fix: fix(api): honor per-call WebSocket query settings (#4138)
- fix: fix(api): preserve Responses WebSocket connection behavior (#4221)
- fix: fix(ci): use an explicit browser demo dependency (#4185)
- fix: fix(examples): detect incomplete WebSocket responses (#4187)
- fix: fix(examples): handle interruptions and disconnects in push-to-talk (#4192)
- fix: fix(examples): stop microphone capture between recordings (#4143)
- fix: fix(realtime): validate beta WebSocket authentication profiles (#4218)
- fix: fix(responses): resolve function arguments within their namespace (#4166)
- fix: fix(responses): validate tool namespaces before runner dispatch (#4167)
- fix: fix: clean up failed WebSocket setup and honor native options (#4121)
- fix: fix: end sync WebSocket recovery when an attempt is interrupted (#4129)
- fix: fix: format API status errors using the server message (#4161)
- fix: fix: honor timed Translation receives during terminal cleanup (#4132)
- fix: fix: keep consumer fixtures clean under strict Pyright (#4204)
- fix: fix: preserve Vertex API root for response lifecycle (#4140)
- fix: fix: preserve client headers in legacy Beta Realtime connections (#4130)
- fix: fix: preserve fallback parsing for PEP 604 unions (#4160)
- …and 71 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
openai/openai-python was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 3 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 4bc7f900c3a1e89cb2f5abcb069c4882e5b2be49 — the exact code this score is about.
- Scored under rubric-2026.11.1 — the same rubric and the same method as every other entry in this index.
- Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.11.1+preprod-7b4ed5af9e84.