openai 3.35.1

Source: https://github.com/openai/openai-python
Tag scanned: v3.35.1
Compared with: v3.35.0 (0 signals introduced since)
Files: 2466 scanned, 34 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 110 info
Scan time: 42.9 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 61 of 61 warn and critical signals; 61 demoted to info.
Disclude version: 4.1.0
Scanned (UTC): 2026-10-22 01:08

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info ~~warn~~ → info by review long-line api_reference/openapi.transformed.yml:1077:1

line length 2410 characters (raw pass, confidence 0.65)
```
            data: {"type":"transcript.text.done","text":"I see skies of blue and clouds of white, the bright blessed days, the dark sacred nights, and I think to myself, what a wonderful world.","logprobs":[{"token":"I","logprob":-0.00007588794,"bytes":[73]},{"token":" see","logprob":-3.1281633e-7,"bytes":[32,115,101,1
```
likely benign LLM, confidence 0.95 Long YAML example line containing a serialized transcript event with logprobs.
Reasoning
Long line is a JSON-encoded streaming event with a transcript and logprobs array in an OpenAPI example. Legitimate documentation data, no obfuscation.

info long-line api_reference/openapi.transformed.yml:5743:1

line length 1879 characters (raw pass, confidence 0.50)

                -d '{"name":"gpt-6-astra","data_source":{"type":"completions","input_messages":{"type":"template","template":[{"role":"developer","content":"Categorize a given news headline into one of the following topics: Technology, Markets, World, Business, or Sports.\n\n# Steps\n\n1. Analyze the content of the new

info long-line api_reference/openapi.transformed.yml:7872:1

line length 783 characters (raw pass, confidence 0.50)

            python: "from openai import OpenAI\nfrom openai.types.fine_tuning import ReinforcementMethod, ReinforcementHyperparameters\nfrom openai.types.graders import StringCheckGrader\n\nclient = OpenAI()\n\nclient.fine_tuning.jobs.create(\n  training_file=\"file-abc\",\n  validation_file=\"file-123\",\n  model=\"o4

info long-line api_reference/openapi.transformed.yml:10951:1

line length 516 characters (raw pass, confidence 0.50)

        description: Group the costs by the specified fields. Supported fields include `project_id`, `user_id`, `line_item`, `api_key_id`, and `api_source`. Support for combining `user_id` with `project_id` grouping or the `project_ids` filter depends on the organization and requested time range. Unsupported combinatio

info long-line api_reference/openapi.transformed.yml:19845:1

line length 687 characters (raw pass, confidence 0.50)

          response: "{\n  \"id\": \"sess_001\",\n  \"object\": \"realtime.session\",\n  \"model\": \"gpt-realtime-2025-08-25\",\n  \"modalities\": [\"audio\", \"text\"],\n  \"instructions\": \"You are a friendly assistant.\",\n  \"voice\": \"alloy\",\n  \"input_audio_format\": \"pcm16\",\n  \"output_audio_format\": \"p

info long-line api_reference/openapi.transformed.yml:19849:1

line length 525 characters (raw pass, confidence 0.50)

      description: "Create an ephemeral API token for use in client-side applications with the\nRealtime API specifically for realtime transcriptions. \nCan be configured with the same session parameters as the `transcription_session.update` client event.\n\nIt responds with a session object, plus a `client_secret` key

info ~~warn~~ → info by review long-line api_reference/openapi.transformed.yml:20395:1

line length 2244 characters (raw pass, confidence 0.65)
```
                      "text": "The file seems to contain excerpts from a letter to the shareholders of Berkshire Hathaway Inc., likely written by Warren Buffett. It covers several topics:\n\n1. **Communication Philosophy**: Buffett emphasizes the importance of transparency and candidness in reporting mistakes and succe
```
likely benign LLM, confidence 0.95 Long example JSON string value in API docs describing a shareholder letter.
Reasoning
Long line is an example response text about a Berkshire Hathaway letter in an API reference. Ordinary prose in a docs example.

info long-line api_reference/openapi.transformed.yml:22138:1

line length 1261 characters (raw pass, confidence 0.50)

            data: {"id":"run_123","object":"thread.run","created_at":1710351818,"assistant_id":"asst_123","thread_id":"thread_123","status":"requires_action","started_at":1710351818,"expires_at":1710352418,"cancelled_at":null,"failed_at":null,"completed_at":null,"required_action":{"type":"submit_tool_outputs","submit_t

info ~~warn~~ → info by review long-line api_reference/openapi.transformed.yml:34967:1

line length 2244 characters (raw pass, confidence 0.65)

                      "text": "The file seems to contain excerpts from a letter to the shareholders of Berkshire Hathaway Inc., likely written by Warren Buffett. It covers several topics:\n\n1. **Communication Philosophy**: Buffett emphasizes the importance of transparency and candidness in reporting mistakes and succe

likely benign LLM, confidence 0.95 Repeated long example response text in OpenAPI reference docs.

Reasoning

Duplicate of the same docs example text at another location; benign long-line formatting.

info long-line api_reference/openapi.transformed.yml:37546:1

line length 506 characters (raw pass, confidence 0.50)

        **Important:** when using JSON mode, you **must** also instruct the model to produce JSON yourself via a system or user message. Without this, the model may generate an unending stream of whitespace until the generation reaches the token limit, resulting in a long-running and seemingly "stuck" request. Also not

info long-line api_reference/openapi.transformed.yml:41982:1

line length 561 characters (raw pass, confidence 0.50)

            Accepts a JSON object that maps tokens (specified by their token ID in the GPT tokenizer) to an associated bias value from -100 to 100. You can use this [tokenizer tool](https://platform.openai.com/tokenizer?view=bpe) to convert text to token IDs. Mathematically, the bias is added to the logits generated by

info long-line api_reference/openapi.transformed.yml:42267:1

line length 604 characters (raw pass, confidence 0.50)

            Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single request, pass an array of strings or array of token arrays. The input must not exceed the max input tokens for the model (8192 tokens for all embedding models), cannot be an empty string, and any array must be

info long-line api_reference/openapi.transformed.yml:43247:1

line length 779 characters (raw pass, confidence 0.50)

          description: The size of the generated images. Defaults to `auto`. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `gpt-image-2.5-sunburst`, `gpt-image-2.5-sunburst-2026-09-08`, `gpt-image-2.5-flare`, and `gpt-image-2.5-flare-2026-09-08`, arbitrary resolutions are supported as `WIDTHxHEIGHT` strings, for example

info long-line api_reference/openapi.transformed.yml:43466:1

line length 759 characters (raw pass, confidence 0.50)

          description: The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `gpt-image-2.5-sunburst`, `gpt-image-2.5-sunburst-2026-09-08`, `gpt-image-2.5-flare`, and `gpt-image-2.5-flare-2026-09-08`, arbitrary resolutions are supported as `WIDTHxHEIGHT` strings, for example `1536x864`. Width a

info long-line api_reference/openapi.transformed.yml:44304:1

line length 566 characters (raw pass, confidence 0.50)

          description: 'The voice to use when generating the audio. Supported built-in voices are `alloy`, `ash`, `ballad`, `coral`, `echo`, `fable`, `onyx`, `nova`, `sage`, `shimmer`, `verse`, `marin`, and `cedar`. You may also provide a custom voice object with an `id`, for example `{ "id": "voice_1234" }`. Previews

info long-line api_reference/openapi.transformed.yml:45740:1

line length 759 characters (raw pass, confidence 0.50)

          description: The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `gpt-image-2.5-sunburst`, `gpt-image-2.5-sunburst-2026-09-08`, `gpt-image-2.5-flare`, and `gpt-image-2.5-flare-2026-09-08`, arbitrary resolutions are supported as `WIDTHxHEIGHT` strings, for example `1536x864`. Width a

info long-line api_reference/openapi.transformed.yml:49474:1

line length 759 characters (raw pass, confidence 0.50)

          description: The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `gpt-image-2.5-sunburst`, `gpt-image-2.5-sunburst-2026-09-08`, `gpt-image-2.5-flare`, and `gpt-image-2.5-flare-2026-09-08`, arbitrary resolutions are supported as `WIDTHxHEIGHT` strings, for example `1536x864`. Width a

info long-line api_reference/openapi.transformed.yml:54374:1

line length 600 characters (raw pass, confidence 0.50)

      description: "Send this event to truncate a previous assistant message’s audio. The server \nwill produce audio faster than realtime, so this event is useful when the user \ninterrupts to truncate audio that has already been sent to the client but not \nyet played. This will synchronize the server's understandi

info long-line api_reference/openapi.transformed.yml:54410:1

line length 631 characters (raw pass, confidence 0.50)

      description: "Send this event to append audio bytes to the input audio buffer. The audio \nbuffer is temporary storage you can write to and later commit. In Server VAD \nmode, the audio buffer is used to detect speech and the server will decide \nwhen to commit. When Server VAD is disabled, you must commit the au

info long-line api_reference/openapi.transformed.yml:54457:1

line length 583 characters (raw pass, confidence 0.50)

      description: "Send this event to commit the user input audio buffer, which will create a \nnew user message item in the conversation. This event will produce an error \nif the input audio buffer is empty. When in Server VAD mode, the client does \nnot need to send this event, the server will commit the audio buff

info long-line api_reference/openapi.transformed.yml:54528:1

line length 1303 characters (raw pass, confidence 0.50)

      description: "This event instructs the server to create a Response, which means triggering \nmodel inference. When in Server VAD mode, the server will create Responses \nautomatically.\n\nA Response will include at least one Item, and may have two, in which case \nthe second will be a function call. These Items w

info long-line api_reference/openapi.transformed.yml:54862:1

line length 750 characters (raw pass, confidence 0.50)

          description: "The default system instructions (i.e. system message) prepended to model \ncalls. This field allows the client to guide the model on desired \nresponses. The model can be instructed on response content and format, \n(e.g. \"be extremely succinct\", \"act friendly\", \"here are examples of good \

info long-line api_reference/openapi.transformed.yml:55475:1

line length 693 characters (raw pass, confidence 0.50)

      description: "Sent by the server when in `server_vad` mode to indicate that speech has been \ndetected in the audio buffer. This can happen any time audio is added to the \nbuffer (unless speech is already detected). The client may want to use this \nevent to interrupt audio playback or provide visual feedback to

info long-line api_reference/openapi.transformed.yml:56628:1

line length 538 characters (raw pass, confidence 0.50)

              "instructions": "Your knowledge cutoff is 2023-10. You are a helpful, witty, and friendly AI. Act like a human, but remember that you aren't a human and that you can't do human things in the real world. Your voice and personality should be warm and engaging, with a lively and playful tone. If interacting

info long-line api_reference/openapi.transformed.yml:56862:1

line length 511 characters (raw pass, confidence 0.50)

      description: "Add a new Item to the Conversation's context, including messages, function \ncalls, and function call responses. This event can be used both to populate a \n\"history\" of the conversation and to add new items mid-stream, but has the \ncurrent limitation that it cannot populate assistant audio messa

info long-line api_reference/openapi.transformed.yml:56958:1

line length 600 characters (raw pass, confidence 0.50)

      description: "Send this event to truncate a previous assistant message’s audio. The server \nwill produce audio faster than realtime, so this event is useful when the user \ninterrupts to truncate audio that has already been sent to the client but not \nyet played. This will synchronize the server's understandi

info long-line api_reference/openapi.transformed.yml:56995:1

line length 910 characters (raw pass, confidence 0.50)

      description: "Send this event to append audio bytes to the input audio buffer. The audio \nbuffer is temporary storage you can write to and later commit. A \"commit\" will create a new\nuser message item in the conversation history from the buffer content and clear the buffer.\nInput audio transcription (if enabl

info long-line api_reference/openapi.transformed.yml:57120:1

line length 1388 characters (raw pass, confidence 0.50)

      description: "This event instructs the server to create a Response, which means triggering \nmodel inference. When in Server VAD mode, the server will create Responses \nautomatically.\n\nA Response will include at least one Item, and may have two, in which case \nthe second will be a function call. These Items w

info long-line api_reference/openapi.transformed.yml:58194:1

line length 535 characters (raw pass, confidence 0.50)

            The default system instructions (i.e. system message) prepended to model calls. This field allows the client to guide the model on desired responses. The model can be instructed on response content and format, (e.g. "be extremely succinct", "act friendly", "here are examples of good responses") and on audio

info long-line api_reference/openapi.transformed.yml:59029:1

line length 693 characters (raw pass, confidence 0.50)

      description: "Sent by the server when in `server_vad` mode to indicate that speech has been \ndetected in the audio buffer. This can happen any time audio is added to the \nbuffer (unless speech is already detected). The client may want to use this \nevent to interrupt audio playback or provide visual feedback to

info long-line api_reference/openapi.transformed.yml:59753:1

line length 547 characters (raw pass, confidence 0.50)

      description: "Returned when a Response is done streaming. Always emitted, no matter the \nfinal state. The Response object included in the `response.done` event will \ninclude all output Items in the Response but will omit the raw audio data.\n\nClients should check the `status` field of the Response to determine

info long-line api_reference/openapi.transformed.yml:60345:1

line length 538 characters (raw pass, confidence 0.50)

              "instructions": "Your knowledge cutoff is 2023-10. You are a helpful, witty, and friendly AI. Act like a human, but remember that you aren't a human and that you can't do human things in the real world. Your voice and personality should be warm and engaging, with a lively and playful tone. If interacting

info long-line api_reference/openapi.transformed.yml:60419:1

line length 538 characters (raw pass, confidence 0.50)

              "instructions": "Your knowledge cutoff is 2023-10. You are a helpful, witty, and friendly AI. Act like a human, but remember that you aren't a human and that you can't do human things in the real world. Your voice and personality should be warm and engaging, with a lively and playful tone. If interacting

info long-line api_reference/openapi.transformed.yml:60628:1

line length 634 characters (raw pass, confidence 0.50)

              Configuration for input audio transcription, defaults to off and can be set to `null` to turn off once on. Input audio transcription is not native to the model, since the model consumes audio directly. Transcription runs asynchronously through [the /audio/transcriptions endpoint](https://developers.openai

info long-line api_reference/openapi.transformed.yml:60778:1

line length 535 characters (raw pass, confidence 0.50)

            The default system instructions (i.e. system message) prepended to model calls. This field allows the client to guide the model on desired responses. The model can be instructed on response content and format, (e.g. "be extremely succinct", "act friendly", "here are examples of good responses") and on audio

info long-line api_reference/openapi.transformed.yml:61019:1

line length 535 characters (raw pass, confidence 0.50)

            The default system instructions (i.e. system message) prepended to model calls. This field allows the client to guide the model on desired responses. The model can be instructed on response content and format, (e.g. "be extremely succinct", "act friendly", "here are examples of good responses") and on audio

info long-line api_reference/openapi.transformed.yml:61461:1

line length 535 characters (raw pass, confidence 0.50)

            The default system instructions (i.e. system message) prepended to model calls. This field allows the client to guide the model on desired responses. The model can be instructed on response content and format, (e.g. "be extremely succinct", "act friendly", "here are examples of good responses") and on audio

info long-line api_reference/openapi.transformed.yml:73688:1

line length 669 characters (raw pass, confidence 0.50)

      description: Options for prompt caching. Supported for `gpt-5.6` and later models. By default, OpenAI automatically chooses one implicit cache breakpoint. You can add explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each request can write up to four breakpoints. For cache matching, OpenAI co

info long-line api_reference/openapi.transformed.yml:78618:1

line length 751 characters (raw pass, confidence 0.50)

          description: The Cyber access program to use for this request. Supported values are `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves the program from the model's Cyber tier and your organization and project access, subject to model-specific eligibility restrictions. By default, mo

info long-line api_reference/openapi.transformed.yml:78643:1

line length 669 characters (raw pass, confidence 0.50)

      description: Options for prompt caching. Supported for `gpt-5.6` and later models. By default, OpenAI automatically chooses one implicit cache breakpoint. You can add explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each request can write up to four breakpoints. For cache matching, OpenAI co

info long-line api_reference/openapi.transformed.yml:80511:1

line length 951 characters (raw pass, confidence 0.50)

              Specifies the processing type used for serving the request.   - If set to 'auto', then the request will be processed with the service tier configured in the Project settings. Unless otherwise configured, the Project will use 'default'.   - If set to 'default', then the request will be processed with the s

info long-line api_reference/openapi.transformed.yml:82408:1

line length 673 characters (raw pass, confidence 0.50)

          description: Options for prompt caching. Supported for `gpt-5.6` and later models. By default, OpenAI automatically chooses one implicit cache breakpoint. You can add explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each request can write up to four breakpoints. For cache matching, OpenA

info long-line api_reference/openapi.transformed.yml:92433:1

line length 589 characters (raw pass, confidence 0.50)

      description: Play one complete audio fixture through the session output. Send this event over the primary WebSocket or a server sideband. Audio must be raw mono PCM16 little-endian at 24 kHz, regardless of the session audio format, and at most 30 seconds. The entire payload is validated before model speech is int

info long-line api_reference/openapi.transformed.yml:95216:1

line length 759 characters (raw pass, confidence 0.50)

          description: The size of the generated images. For `gpt-image-2`, `gpt-image-2-2026-04-21`, `gpt-image-2.5-sunburst`, `gpt-image-2.5-sunburst-2026-09-08`, `gpt-image-2.5-flare`, and `gpt-image-2.5-flare-2026-09-08`, arbitrary resolutions are supported as `WIDTHxHEIGHT` strings, for example `1536x864`. Width a

info long-line api_reference/openapi.transformed.yml:99415:1

line length 951 characters (raw pass, confidence 0.50)

              Specifies the processing type used for serving the request.   - If set to 'auto', then the request will be processed with the service tier configured in the Project settings. Unless otherwise configured, the Project will use 'default'.   - If set to 'default', then the request will be processed with the s

info long-line api_reference/openapi.transformed.yml:99440:1

line length 669 characters (raw pass, confidence 0.50)

      description: Options for prompt caching. Supported for `gpt-5.6` and later models. By default, OpenAI automatically chooses one implicit cache breakpoint. You can add explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each request can write up to four breakpoints. For cache matching, OpenAI co

info long-line api_reference/openapi.transformed.yml:106600:1

line length 669 characters (raw pass, confidence 0.50)

      description: Options for prompt caching. Supported for `gpt-5.6` and later models. By default, OpenAI automatically chooses one implicit cache breakpoint. You can add explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each request can write up to four breakpoints. For cache matching, OpenAI co

info long-line api_reference/openapi.transformed.yml:106605:1

line length 751 characters (raw pass, confidence 0.50)

          description: The Cyber access program to use for this request. Supported values are `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves the program from the model's Cyber tier and your organization and project access, subject to model-specific eligibility restrictions. By default, mo

info long-line docs/architecture/security-model.md:35:1

line length 1109 characters (raw pass, confidence 0.50)

| Streaming and authenticated WebSockets | Incrementally decode SSE and exchange authenticated current or beta Realtime/Responses WebSocket messages through distinct sync and async connection paths. | [src/openai/_streaming.py:53](../../src/openai/_streaming.py), [src/openai/resources/realtime/realtime.py:683](../../sr

info ~~warn~~ → info by review long-line docs/architecture/security-model.md:54:1

line length 2482 characters (raw pass, confidence 0.65)
```
| Legacy module-level client | Global/environment-selected OpenAI, Azure, or Bedrock credential and destination | Module `api_type` starts from `OPENAI_API_TYPE`. `_load_client()` fills unset Azure endpoint/version globals from environment; only when `api_type` is unset, it rejects `OPENAI_API_KEY` in the environment t
```
likely benign LLM, confidence 0.93 Long markdown table row documenting client credential sourcing.
Reasoning
Long markdown table row describing credential handling in a security model doc. Prose, no code execution or obfuscation.

info ~~warn~~ → info by review long-line docs/architecture/security-model.md:65:1

line length 2772 characters (raw pass, confidence 0.65)

| Current and beta Realtime/Responses WebSockets | WebSocket destination and client auth headers | All current and beta paths use explicit `websocket_base_url` or transform the configured HTTP base to a WebSocket scheme, then merge client auth with caller extra headers. Only Realtime branches into Azure `_configure_rea

likely benign LLM, confidence 0.93 Long markdown table row on WebSocket destination and auth headers.

Reasoning

Long markdown table row describing WebSocket auth destinations. Documentation prose only.

info long-line docs/architecture/security-model.md:353:1

line length 1687 characters (raw pass, confidence 0.50)

| High | Legacy module-client selection or cache regression routes an OpenAI, Azure, or Bedrock credential through the wrong provider. | Mutable module globals or environment signals must cross a broken precedence, ambiguity, forwarding, or reset boundary; the caller deliberately setting a coherent provider configurati

info ~~warn~~ → info by review long-line docs/architecture/security-model.md:354:1

line length 2534 characters (raw pass, confidence 0.65)
```
| High | A current or beta Realtime/Responses WebSocket regression sends client auth to the wrong peer or redirect target. | A sync direct-connect or async wrapper path must lose its destination/header binding; caller-selected explicit WebSocket configuration alone is insufficient. | API credential disclosure; Azure `a
```
likely benign LLM, confidence 0.93 Long markdown threat-model table row on WebSocket credential disclosure.
Reasoning
Long markdown table row describing a threat-model regression scenario. Documentation prose only.

info long-line docs/architecture/security-model.md:365:1

line length 1490 characters (raw pass, confidence 0.50)

| Medium | Monthly review input or output escapes its intended isolation or publication boundary. | A regression lets independently mutable lifecycle/PyPI data expose the action-held key, mutate protected workspace state, leak sensitive output to the step summary, escape the bounded issue body into publisher commands/m

info long-line docs/architecture/security-model.md:366:1

line length 1595 characters (raw pass, confidence 0.50)

| High | Castiron candidate data escapes the trusted reporter/publisher boundary and changes published commit statuses or PR comments. | Candidate Git objects, stale run metadata, or an untrusted artifact must bypass provenance/freshness/payload/artifact checks before a write-capable publisher acts; normal candidate in

info ~~warn~~ → info by review dynamic-import scripts/run-steady:5:1

`source` called with a dynamic path — sourcing a variable script path (ast pass, confidence 0.75)
```
STEADY_ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
source "$STEADY_ROOT/scripts/steady/settings"
steady_verify
```
likely benign LLM, confidence 0.80 Launcher script sources its sibling settings file via a script-relative path.
Reasoning
Sources a settings file located relative to the script's own directory, a common bash pattern. The path is derived from the repo root, not attacker input, though the file is still executed at runtime.
info ~~critical~~ → info by review dynamic-execution scripts/run-steady:9:1

`exec` called with a dynamic (variable/substitution) path (ast pass, confidence 0.85)
```
# Keep the caller's working directory so relative spec paths keep working.
exec "$DENO_DIRECTORY/$DENO_BINARY" run --cached-only --frozen \
  --config "$STEADY_SOURCE/deno.json" \
  --allow-read --allow-net --allow-env --allow-write \
```
likely benign LLM, confidence 0.75 Launcher execs a cached Deno binary via variable path with restricted cache flags.
Reasoning
exec runs a Deno binary from a configured cache directory with frozen, cached-only flags and fixed permissions. It is a dynamic path, but the variables come from the repo's own settings, which is typical for a launcher. Still worth reviewing that DENO_DIRECTORY cannot be attacker-controlled.
info ~~warn~~ → info by review dynamic-import scripts/steady/install:5:1

`source` called with a dynamic path — sourcing a variable script path (ast pass, confidence 0.75)
```
STEADY_ROOT="$(cd "$(dirname "$0")/../.." && pwd -P)"
source "$STEADY_ROOT/scripts/steady/settings"

mkdir -p "$STEADY_CACHE"
```
likely benign LLM, confidence 0.80 Install script sources its sibling settings file by relative path.
Reasoning
Same script-relative sourcing of the settings file as the launcher; a standard install-script pattern with no encoded or hidden content.
info ~~warn~~ → info by review dynamic-execution scripts/steady/install:35:1

command name is a variable (`$DENO_DIRECTORY`, `$DENO_BINARY`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
steady_verify
"$DENO_DIRECTORY/$DENO_BINARY" cache --frozen --config "$STEADY_SOURCE/deno.json" "$STEADY_SOURCE/cmd/steady.ts" >&2

if [[ "${1:-}" == '--print-executable' ]]; then
```
likely benign LLM, confidence 0.75 Install script invokes a Deno binary from configured variables to cache dependencies.
Reasoning
Runs deno cache using variables defined in the settings file, which is a normal bootstrap step. The command name being a variable is a flag, not evidence of malice, but the values come from the environment-sourced settings.
info ~~warn~~ → info by review dynamic-attribute src/openai/__init__.py:139:13

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            value = getattr(import_module(module, __name__), name)
            globals()[name] = value
            return value
        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
```
likely benign LLM, confidence 0.90 Lazy-import module __getattr__ that imports submodules by name and caches them.
Reasoning
Standard PEP 562 module __getattr__ lazy-loading pattern caching resolved names in globals. Legitimate and common in the openai SDK.
info ~~warn~~ → info by review dynamic-attribute src/openai/lib/streaming/__init__.py:19:13

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            value = getattr(import_module("._assistants", __name__), name)
            globals()[name] = value
            return value
        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
```
likely benign LLM, confidence 0.90 Lazy-loading __getattr__ in the streaming package for relative submodules.
Reasoning
Same PEP 562 lazy-import __getattr__ pattern limited to relative submodule imports. Benign.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/__init__.py:350:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading __getattr__ in the OpenAI SDK resources package that caches resolved attributes into globals.
Reasoning
The snippet is the standard PEP 562 module-level __getattr__ lazy-loading pattern. It raises AttributeError for unknown names and caches resolved submodules via globals()[name] = value. This is a normal, well-known idiom for lazily importing SDK resource modules, not obfuscation.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the admin resources package.
Reasoning
Same PEP 562 lazy-loading __getattr__ idiom: an AttributeError for unknown names and a globals() cache for resolved attributes. Routine SDK module structure.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/organization/__init__.py:233:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the admin organization resources package.
Reasoning
Standard PEP 562 lazy-attribute loader that caches into globals() and raises AttributeError otherwise. Matches the SDK's generated package layout and carries no malicious signal.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/organization/groups/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the organization groups resources package.
Reasoning
Standard lazy-import __getattr__ with a globals() cache, identical to the other generated package initializers. No payload, network, or execution signal.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/organization/projects/__init__.py:230:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the organization projects resources package.
Reasoning
Standard PEP 562 lazy loader with a globals() cache. The reach-by-name is only the mechanism for deferred submodule attribute access, consistent with the SDK's generated code.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/organization/projects/groups/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the project groups resources package.
Reasoning
Same lazy-attribute idiom with an AttributeError fallback and globals() caching. Benign SDK boilerplate.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/organization/projects/service_accounts/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the project service accounts resources package.
Reasoning
Standard lazy-import __getattr__ pattern with globals() caching and an AttributeError fallback. No execution or decoding of external data.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/organization/projects/users/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the project users resources package.
Reasoning
Standard PEP 562 lazy loader using globals() caching. This is a routine generated-package pattern with no malicious indicators.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/admin/organization/users/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the organization users resources package.
Reasoning
Same lazy-attribute idiom with an AttributeError fallback and a globals() cache. Benign SDK module structure.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/audio/__init__.py:98:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the audio resources package.
Reasoning
Standard PEP 562 lazy-loader boilerplate that caches resolved submodules in globals(). No suspicious data flow.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/__init__.py:113:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the beta resources package.
Reasoning
Standard lazy-import __getattr__ with globals() caching and an AttributeError fallback, consistent with the SDK's package layout.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/agents/__init__.py:83:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the beta agents resources package.
Reasoning
Standard PEP 562 lazy loader with globals() caching. Routine pattern with no encoded payloads or dynamic execution of external content.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/agents/environments/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the agent environments resources package.
Reasoning
Same lazy-attribute idiom with globals() caching and an AttributeError fallback. Benign generated-package boilerplate.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/agents/sessions/__init__.py:128:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the agent sessions resources package.
Reasoning
Standard lazy-import __getattr__ with globals() caching. The pattern only resolves the SDK's own submodules and shows no malicious behavior.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/agents/sessions/subagents/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the subagents resources package.
Reasoning
Standard PEP 562 lazy loader using globals() caching. Routine SDK package boilerplate.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/agents/sessions/subagents/turns/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.94 Lazy-loading module __getattr__ in the subagent turns resources package.
Reasoning
Same lazy-attribute idiom with globals() caching and an AttributeError fallback. Benign SDK module structure.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/agents/sessions/turns/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A module __getattr__ that lazily imports a submodule and caches it in globals().
Reasoning
The snippet is the standard lazy-loading idiom: a module-level __getattr__ resolves a name, raises AttributeError if unknown, and caches the value via globals()[name] = value. The file path matches the OpenAI SDK's generated package layout, so this is a legitimate import optimization, not hidden execution.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/agents/vaults/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy module attribute loader that caches resolved names in globals().
Reasoning
Same lazy-attribute caching pattern: unknown names raise AttributeError and resolved values are stored back into the module namespace. No command execution, decoding, or network activity appears in the snippet, and the path is a normal SDK resource package.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/chatkit/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A module __getattr__ that defers loading of a chatkit resource and caches it.
Reasoning
The snippet shows the usual deferred-import getattr pattern used to avoid eager loading of resource submodules. Writing the resolved value into globals() is a standard caching step, and nothing in the snippet suggests malicious intent.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/responses/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy submodule loader for beta responses that caches results in globals().
Reasoning
Standard lazy-import idiom: an AttributeError is raised for unknown names, otherwise the value is cached in the module globals. The file sits within the OpenAI SDK resource tree, consistent with generated code.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/threads/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A module-level __getattr__ that lazily resolves and caches thread resources.
Reasoning
The snippet is a benign deferred attribute resolver. It raises for missing names and memoizes resolved objects in globals(). This is a common pattern for reducing import cost in large SDK packages.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/beta/threads/runs/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy attribute resolver for thread runs that memoizes into module globals.
Reasoning
This is the standard lazy-loading __getattr__ with a globals() cache write. It is typical SDK plumbing, with no decoding, dynamic code execution, or shell use visible in the snippet.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/chat/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy chat resource loader that caches resolved names in module globals.
Reasoning
The snippet matches the SDK's lazy-import pattern: unknown attributes raise AttributeError, and resolved values are cached in globals(). This is ordinary module-loading code and not evasion.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/chat/completions/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy loader for chat completions that caches resolved attributes in globals().
Reasoning
Standard deferred-import __getattr__ with memoization via globals(). Nothing in the snippet indicates code execution, obfuscated names, or data exfiltration.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/containers/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy container resource loader that memoizes into module globals.
Reasoning
The snippet is the usual lazy-attribute idiom for SDK resource packages. The globals() write only memoizes an already-imported submodule attribute.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/containers/files/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy loader for container files that caches resolved names in globals().
Reasoning
Same benign module __getattr__ and globals() caching pattern used across the SDK's resource packages. No suspicious operations are visible.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/conversations/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy conversations resource loader that caches results in module globals.
Reasoning
This is a standard deferred-import getattr that raises for unknown names and caches resolved values. It is conventional SDK packaging code.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/evals/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy evals resource loader that memoizes attributes in globals().
Reasoning
The snippet is the typical module __getattr__ lazy-loading idiom with a globals() memoization step. It has no dynamic execution or encoded payload.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/evals/runs/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy eval-runs loader that caches resolved names in module globals.
Reasoning
Standard lazy-import pattern: AttributeError for unknown names, then caching into globals(). Consistent with the rest of the SDK's __init__ modules.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/fine_tuning/__init__.py:83:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy fine-tuning resource loader that caches resolved names in globals().
Reasoning
This is the benign lazy-attribute idiom used for deferring submodule imports. The globals() cache write is ordinary and no malicious behavior appears in the snippet.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/fine_tuning/alpha/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy alpha fine-tuning loader that memoizes into module globals.
Reasoning
Standard module __getattr__ with memoization into globals(). It is normal SDK code for lazily exposing alpha fine-tuning resources.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/fine_tuning/checkpoints/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.93 A lazy checkpoints resource loader that caches resolved attributes in globals().
Reasoning
The snippet is the usual deferred import with AttributeError on miss and globals() caching on hit. It is a common, legitimate Python packaging technique.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/fine_tuning/jobs/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
This is the standard lazy-loading __getattr__ pattern for a package __init__, caching the resolved submodule attribute in globals(). Benign and common in SDKs like the OpenAI Python client.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/live/__init__.py:67:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Same lazy __getattr__ caching idiom as the other OpenAI SDK package initializers; it only resolves known resource names and raises AttributeError otherwise.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/realtime/__init__.py:83:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Standard lazy-import __getattr__ pattern with globals caching; no execution of external data.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/realtime/translations/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Identical lazy-loading __getattr__ boilerplate; benign SDK packaging code.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/responses/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Standard lazy-loading __getattr__ idiom in an SDK package init; no dynamic code execution.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/safety/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Standard lazy-loading __getattr__ idiom; benign.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/skills/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Standard lazy-loading __getattr__ idiom; benign.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/skills/versions/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Standard lazy-loading __getattr__ idiom; benign.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/uploads/__init__.py:53:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Standard lazy-loading __getattr__ idiom; benign.
info ~~warn~~ → info by review dynamic-attribute src/openai/resources/vector_stores/__init__.py:68:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
        globals()[name] = value
        return value
```
likely benign LLM, confidence 0.95 Lazy module attribute loader that caches resolved names into globals().
Reasoning
Standard lazy-loading __getattr__ idiom; benign.
info ~~warn~~ → info by review encoding-base64 tests/lib/test_webhooks.py:24:22

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
# Standardized test constants (matches TypeScript implementation)
TEST_SECRET = "whsec_RdvaYFYUXuIFuEbvZHwMfYFhUf7aMYjYcmM24+Aj40c="
TEST_PAYLOAD = '{"id": "evt_685c059ae3a481909bdc86819b066fb6", "object": "event", "created_at": 1750861210, "type": "response.completed", "data": {"id": "resp_123"}}'
```
likely benign LLM, confidence 0.93 Test fixture webhook secret string in a unit test.
Reasoning
The flagged value is a clearly labeled test webhook secret constant (whsec_ prefix, matching the TypeScript SDK) used to verify signature handling. Raw base64 pattern in a test fixture has a high false-positive rate.
info ~~warn~~ → info by review encoding-base64 tests/lib/test_webhooks.py:28:22

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
TEST_WEBHOOK_ID = "wh_685c059ae39c8190af8c71ed1022a24d"
TEST_SIGNATURE = "v1,gUAg4R2hWouRZqRQG4uJypNS8YK885G838+EHb4nKBY="
SIP_EVENT_TYPES = ["live.call.incoming", "live.transport.incoming", "realtime.call.incoming"]
SIP_MEDIA_SECURITY_VALUES = [None, "rtp", "srtp", "future_media_security"]
```
likely benign LLM, confidence 0.93 Test fixture webhook signature string in a unit test.
Reasoning
The value is a test webhook signature constant alongside other test fixtures; ordinary test data, not obfuscation.
info ~~warn~~ → info by review dynamic-execution tests/test_uv_workflows.py:1243:12

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
    # Compile once per worker, but execute with fresh globals for every case.
    return compile(security_dependency_floor_program(), str(ROOT / "scripts/check-dependency-security.py"), "exec")
```
likely benign LLM, confidence 0.85 Test helper compiles a dependency-security checker script for in-process execution.
Reasoning
Compiling a generated checker program in a test harness to run it in-process with fresh globals is an ordinary testing technique; the target is a repo script under scripts/. Test-only context lowers risk, though compile of generated source is worth a glance.
info ~~warn~~ → info by review dynamic-execution tests/test_uv_workflows.py:1522:19

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
    # the same checker and Git stub in-process; keep real CLI coverage below.
    git_program = compile(fake_git.read_text(), str(fake_git), "exec")

    def run_git(args: list[str], **_kwargs: Any) -> subprocess.CompletedProcess[str]:
```
likely benign LLM, confidence 0.88 Test compiles a fake git stub script to run in-process.
Reasoning
The code reads a fake git stub from a test fixture file and compiles it to stub out git calls in-process. This is a test double, with the comment explaining real CLI coverage is elsewhere.
info ~~warn~~ → info by review dynamic-execution tests/test_uv_workflows.py:1529:13

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
            patch.setattr(sys, "argv", args)
            exec(git_program, {"__name__": "__main__"})
        return subprocess.CompletedProcess(args, 0, output.getvalue(), "")
```
likely benign LLM, confidence 0.88 Test executes a compiled fake git stub in-process.
Reasoning
exec runs the compiled fake git test stub with a restricted globals dict and patched argv; this is the consumer of the compile above, used purely for test mocking within the repo's own test files.
info ~~warn~~ → info by review dynamic-execution tests/test_uv_workflows.py:1543:13

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        try:
            exec(compiled_security_dependency_floor_program(), {"__name__": "__main__"})
        except SystemExit as error:
            if isinstance(error.code, int):
```
likely benign LLM, confidence 0.70 A test exec()s a program generated by a local helper and checks its SystemExit code.
Reasoning
The exec call runs the result of a local helper, compiled_security_dependency_floor_program(), in a test module that catches SystemExit. That fits a test harness executing a generated check script. The snippet does not show where the program text comes from, so a hidden payload cannot be fully ruled out, but nothing here indicates a dropper or remote fetch.
info ~~warn~~ → info by review dynamic-execution tests/utils.py:32:12

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
def evaluate_forwardref(forwardref: ForwardRef, globalns: dict[str, Any]) -> type:
    return eval(str(forwardref), globalns)  # type: ignore[no-any-return]
```
likely benign LLM, confidence 0.90 A test helper evaluates a ForwardRef string against a namespace to resolve type annotations.
Reasoning
This is the standard pattern for resolving a typing.ForwardRef against a globals dict, used in test utilities for type-annotation evaluation. The input is a type annotation string from the code under test, not attacker-controlled network or file data. The eval is local and expected.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.1.0
git clone https://github.com/openai/openai-python openai-python && cd openai-python
git checkout v3.35.1
disclude scan --severity info --diff v3.35.0 .