openai 3.34.0

Source: https://github.com/openai/openai-python
Tag scanned: v3.34.0
Compared with: v3.33.0 (0 signals introduced since)
Files: 2462 scanned, 37 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 110 info
Scan time: 41.2 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 61 of 61 warn and critical signals; 61 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-18 21:41

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.97 Long YAML example line containing a JSON transcript event with logprobs.
Reasoning
Long line is a JSON-encoded streaming example with logprobs data inside a YAML doc. Raw long-line signal on documentation data; no malicious content.

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.97 Long example text string in an OpenAPI spec describing a letter.
Reasoning
Long string example of a model response about a Berkshire letter, inside an OpenAPI spec. Plain prose in an API example, no obfuscation.

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.97 Duplicate long example text in the OpenAPI spec.

Reasoning

Duplicate of the same example prose at another location in the generated OpenAPI doc. Benign documentation content.

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:54367: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:54403: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:54450: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:54521: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:54855: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:55468: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:56621: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:56855: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:56951: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:56988: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:57113: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:58187: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:59022: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:59746: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:60338: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:60412: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:60621: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:60771: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:61012: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:61454: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:73681: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:78611: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:78636: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:80504: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:82401: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:92424: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:95207: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:99406: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:99431: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:106591: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:106596: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.96 Long markdown table row documenting client credential sources.
Reasoning
Long markdown table row describing credential handling for the SDK. Documentation prose, long only because of table cell width.
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.96 Long markdown table row documenting WebSocket destinations and auth headers.
Reasoning
Long markdown table row documenting WebSocket auth destinations. Plain documentation text.

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.96 Long markdown table row describing a WebSocket credential-disclosure risk.
Reasoning
Long markdown table row in a threat/risk table. Documentation prose with no executable content.

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 a settings file located relative to its own root.
Reasoning
Sources a settings file whose path is derived from the script's own directory via dirname and pwd -P. This is a normal bash launcher pattern; the path is not attacker-controlled input.
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.70 Launcher execs a cached Deno binary with a variable path and fixed flags.
Reasoning
exec runs a binary built from DENO_DIRECTORY and DENO_BINARY, which are presumably set in the sourced settings file from the repo. Dynamic exec is expected for a launcher, and the flags are restrictive with --cached-only and --frozen, but the variable path leaves some doubt about where it resolves.
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 a settings file relative to its own root.
Reasoning
Same self-relative sourcing pattern as the launcher: the settings path is computed from the script's own location. Standard bash install-script behavior.
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 runs deno cache using settings-defined binary path.
Reasoning
Runs deno cache using a binary path from variables defined in the settings file sourced earlier. This is an install step for the repo's own toolchain; the variables are not from untrusted input in the snippet.
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-loading module __getattr__ that imports submodules by name.
Reasoning
Standard PEP 562 lazy module attribute loading: getattr via import_module of a known submodule, cached in globals, else AttributeError. Common and legitimate 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 module __getattr__ for streaming submodules.
Reasoning
Same lazy-import __getattr__ pattern importing a relative submodule and caching it in globals. Legitimate lazy-loading idiom.
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.95 Module-level lazy attribute loader in the openai SDK that caches resolved submodule attributes via globals().
Reasoning
This is the standard lazy-loading __getattr__ pattern for Python package submodules: it raises AttributeError for unknown names and caches resolved values in globals(). The name is a module-local attribute name, not attacker-controlled input from the network, and the code is part of the openai SDK, a well-known legitimate package.
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.95 Lazy-loading module __getattr__ in the openai admin resources package that caches attributes in globals().
Reasoning
Same standard lazy-import __getattr__ pattern with AttributeError fallback and globals caching; consistent with the openai SDK's generated resource packages.
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.95 Lazy-loading module __getattr__ for the openai admin organization resources package.
Reasoning
Identical generated lazy-loader pattern in a nested openai SDK package; raises for unknown names and caches resolved attributes. No payload, decoding, or execution of external data.
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.95 Lazy-loading module __getattr__ for openai organization groups resources.
Reasoning
Same generated lazy-import __getattr__ with globals caching; benign SDK structure with no dynamic execution.
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.95 Lazy-loading module __getattr__ for openai organization projects resources.
Reasoning
Standard lazy-loader __getattr__ caching attributes via globals in the openai SDK; no evidence of malicious behavior.
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.95 Lazy-loading module __getattr__ for openai project groups resources.
Reasoning
Generated lazy-import __getattr__ pattern with AttributeError on miss and globals caching; typical of SDK packages.
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.95 Lazy-loading module __getattr__ for openai project service account resources.
Reasoning
Same lazy-loader pattern; caches submodule attributes by name in the module globals. Benign SDK code.
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.95 Lazy-loading module __getattr__ for openai project users resources.
Reasoning
Generated lazy-import __getattr__ with globals caching and AttributeError fallback; 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.95 Lazy-loading module __getattr__ for openai organization users resources.
Reasoning
Standard lazy-loader __getattr__ pattern in the openai SDK package layout; benign.
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.95 Lazy-loading module __getattr__ for openai audio resources.
Reasoning
Lazy-loading __getattr__ with globals caching, identical to the other openai SDK package initializers; no decoding or execution of external content.
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.95 Lazy-loading module __getattr__ for openai beta resources.
Reasoning
Standard generated lazy-import __getattr__ in the openai beta resources package; benign.
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.95 Lazy-loading module __getattr__ for openai beta agents resources.
Reasoning
Same lazy-loader pattern with globals caching; no suspicious behavior.
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.95 Lazy-loading module __getattr__ for openai beta agent environments resources.
Reasoning
Generated lazy-import __getattr__ with AttributeError fallback; typical SDK code.
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.95 Lazy-loading module __getattr__ for openai beta agent sessions resources.
Reasoning
Standard lazy-loader __getattr__ caching submodule attributes in globals; benign.
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.95 Lazy-loading module __getattr__ for openai beta agent session subagents resources.
Reasoning
Same generated lazy-import pattern; no evidence of obfuscation or malicious intent.
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.95 Lazy-loading module __getattr__ for openai beta agent session subagent turns resources.
Reasoning
Standard lazy-loader __getattr__ with globals caching in a deeply nested SDK package; benign and consistent with the rest of the package.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
The snippet is the standard PEP 562 lazy-import pattern: a module-level __getattr__ raises AttributeError for unknown names and caches resolved submodule attributes via globals(). It only resolves names within the package's own module, and nothing here runs external input or executes code.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Same PEP 562 lazy-import pattern: __getattr__ resolves a name and stores it in globals() for caching. It is a generated SDK package layout with no dynamic execution or encoded payload.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Standard lazy-attribute caching via globals() in a package __init__; the raise and assignment are ordinary module-attribute handling for the SDK's resource classes.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
The snippet is the usual PEP 562 __getattr__ with globals() caching, which is a common and legitimate way to defer imports in a large generated SDK. There is no sign of malicious payload.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Lazy module attribute resolution with caching into globals(); the AST pass flags the generic globals() write, but the code only exposes SDK symbols by name.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Standard PEP 562 lazy import: __getattr__ raises for unknown names and caches known ones in globals(). This is a legitimate pattern for deferring submodule imports.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Lazy attribute loader with globals() caching, a well-known benign idiom for reducing import cost in SDK packages. Nothing in the snippet executes external data.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Same PEP 562 lazy-import idiom; the globals() write only memoizes an already-resolved attribute within this module.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Lazy __getattr__ with caching into globals(); the flagged pattern is the standard way to defer imports and has no network, shell, or decode behavior.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
PEP 562 lazy attribute resolution with memoization in globals(). This is ordinary package plumbing for a generated SDK.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Standard lazy import via module __getattr__ that caches into globals(). The snippet contains no dynamic execution or obfuscated strings.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Lazy-loading idiom using globals() memoization; the AST rule is generic and this instance is an expected SDK pattern.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
PEP 562 __getattr__ with caching into globals(); a legitimate deferred-import pattern with no malicious indicators in the snippet.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Standard module-level __getattr__ caching resolved names into globals(), a common lazy-import technique in Python packages. No encoded data or execution is present.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Lazy-import __getattr__ with globals() caching, matching the rest of the SDK's package layout. Benign.
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 Lazy-loading __getattr__ in a package __init__.py that caches resolved attributes into module globals.
Reasoning
Same PEP 562 lazy-attribute pattern. The globals() write memoizes a resolved SDK submodule attribute and does not execute external content.
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-import __getattr__ caching attributes via globals() in the OpenAI SDK package __init__.
Reasoning
Standard lazy-loading module __getattr__ pattern caching resolved submodule attributes into globals; the name comes from attribute access on the module and is bounded by the module's own import map, with no external input or execution.
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-import __getattr__ caching attributes via globals() in the live resources package.
Reasoning
Same benign lazy-loading __getattr__ idiom used across the SDK; it only resolves known attribute 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-import __getattr__ caching attributes via globals() in the realtime resources package.
Reasoning
Standard lazy-loading pattern in a package __init__; no untrusted input reaches the name lookup.
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-import __getattr__ caching attributes via globals() in the realtime translations package.
Reasoning
Identical benign lazy-loading __getattr__ pattern; the flagged line only memoizes a resolved export.
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-import __getattr__ caching attributes via globals() in the responses resources package.
Reasoning
Standard lazy-import idiom for SDK submodules; the dynamic lookup is bounded and raises on unknown names.
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-import __getattr__ caching attributes via globals() in the safety resources package.
Reasoning
Benign lazy-loading module attribute pattern with no external execution or data source.
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-import __getattr__ caching attributes via globals() in the skills resources package.
Reasoning
Standard lazy-import __getattr__ idiom; resolves only the package's own exports.
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-import __getattr__ caching attributes via globals() in the skills versions package.
Reasoning
Same benign lazy-loading pattern in a nested package __init__.
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-import __getattr__ caching attributes via globals() in the uploads resources package.
Reasoning
Standard lazy-import module __getattr__ pattern; no malicious indicators.
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-import __getattr__ caching attributes via globals() in the vector stores resources package.
Reasoning
Benign lazy-loading idiom in the vector stores package __init__.
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.90 Test fixture webhook secret string that resembles base64.
Reasoning
The flagged value is a test webhook secret constant with a base64-looking suffix; it is a test fixture, and raw-pass base64 hits on short strings have high false-positive rates.
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.90 Test fixture webhook signature string that resembles base64.
Reasoning
A test signature constant used for webhook verification tests; plain test data, not an obfuscated payload.
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.80 Test helper compiling a generated checker script for in-process execution.
Reasoning
Compiles a script generated by a helper inside a test to run a dependency-security checker repeatedly; test harness code, not a dropper. Some doubt because the source is a generated program rather than a literal.
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.85 Test code compiling a fake git stub from a fixture file.
Reasoning
Compiles a fake git stub script read from a test fixture file to run in-process during tests; this is test scaffolding for mocking subprocess calls.
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.85 Test code executing a fake git stub in-process to mock subprocess calls.
Reasoning
Executes the precompiled fake git stub with a fresh globals dict inside a test to simulate git output; test-only mocking, no network or shell payload.
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.72 A test in uv's test suite execs a program produced by a local helper and handles SystemExit from it.
Reasoning
The exec call runs the output of a local helper, compiled_security_dependency_floor_program(), with a minimal __name__ globals dict, and catches SystemExit. This is a test harness executing a program it generated itself, inside a test file of a package manager project. The snippet shows no network fetch, decoding, or obfuscation. The uncertainty is that exec of generated code is unusual and the helper's body is not shown, so it could in principle hide something.
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 utility evaluates a ForwardRef's string against a namespace to resolve type annotations.
Reasoning
This is a standard forward-reference resolver for type-annotation tests: it evals the string form of a typing.ForwardRef against a supplied globals dict, and the type: ignore comment suggests a deliberate, understood use. The input comes from type annotations in test code, not from untrusted data, and the pattern is common in typing-related libraries.

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.0.0
git clone https://github.com/openai/openai-python openai-python && cd openai-python
git checkout v3.34.0
disclude scan --severity info --diff v3.33.0 .