openai 7.16.0 → 7.17.0

package/lib/ChatCompletionStream.mjs

@@ -1,13 +1,14 @@
-var _ChatCompletionStream_instances, _ChatCompletionStream_params, _ChatCompletionStream_audioDoneChoiceIndexes, _ChatCompletionStream_choiceEventStates, _ChatCompletionStream_currentChatCompletionSnapshot, _ChatCompletionStream_hasAutoParseableTool, _ChatCompletionStream_partialJSONParseBudget, _ChatCompletionStream_beginRequest, _ChatCompletionStream_getChoiceEventState, _ChatCompletionStream_addChunk, _ChatCompletionStream_emitToolCallDoneEvent, _ChatCompletionStream_emitContentDoneEvents, _ChatCompletionStream_validateStructuredSnapshots, _ChatCompletionStream_endRequest, _ChatCompletionStream_accumulateChatCompletion;
+var _ChatCompletionStream_instances, _ChatCompletionStream_params, _ChatCompletionStream_rejectsUnfinishedTurns, _ChatCompletionStream_audioDoneChoiceIndexes, _ChatCompletionStream_choiceEventStates, _ChatCompletionStream_currentChatCompletionSnapshot, _ChatCompletionStream_hasAutoParseableTool, _ChatCompletionStream_partialJSONParseBudget, _ChatCompletionStream_beginRequest, _ChatCompletionStream_getChoiceEventState, _ChatCompletionStream_addChunk, _ChatCompletionStream_emitToolCallDoneEvent, _ChatCompletionStream_emitContentDoneEvents, _ChatCompletionStream_validateStructuredSnapshots, _ChatCompletionStream_endRequest, _ChatCompletionStream_accumulateChatCompletion;
 import { __classPrivateFieldGet, __classPrivateFieldSet } from "../internal/tslib.mjs";
 import { MalformedJSON, partialParse } from "../_vendor/partial-json-parser/parser.mjs";
-import { APIError, APIUserAbortError, ContentFilterFinishReasonError, LengthFinishReasonError, OpenAIError, } from "../error.mjs";
+import { APIError, ContentFilterFinishReasonError, LengthFinishReasonError, OpenAIError } from "../error.mjs";
 import { observeJSONRequestBody } from "../internal/request-options.mjs";
 import { uuid4 } from "../internal/utils/uuid.mjs";
 import { hasOwn } from "../internal/utils/values.mjs";
 import { hasAutoParseableInput, isAutoParsableTool, isChatCompletionFunctionTool, isParseableResponseFormat, maybeParseChatCompletion, parseResponseFormatContent, shouldParseToolCall, } from "../lib/parser.mjs";
 import { Stream } from "../streaming.mjs";
 import { AbstractChatCompletionRunner } from "./AbstractChatCompletionRunner.mjs";
+// oxlint-disable-next-line anti-slop/no-unknown-returns -- Partial JSON may have any shape; callers validate or parse it against their response schema.
 function parseStructuredStreamingJSON(content) {
     try {
         return partialParse(content);
@@ -27,6 +28,7 @@ export function makeChatCompletionReadableStreamMessageChunk(chunk, message, too
     const payload = {
         type: 'message',
         message,
+        // Spread creates an own data property without invoking inherited setters or changing the object prototype.
         ...(toolCallIds ? { tool_call_ids: toolCallIds } : {}),
     };
     return {
@@ -47,6 +49,7 @@ function getChatCompletionReadableStreamMessage(item) {
     if ('type' in item) {
         return item;
     }
+    // SAFETY: This decoder reads the SDK's tagged readable-stream envelope; JSON parsing restores its serialized message fields for the stream accumulator.
     return JSON.parse(item.object.slice(CHAT_COMPLETION_READABLE_STREAM_MESSAGE_PREFIX.length));
 }
 // The Chat Completions schema limits n to 128. Replayed streams do not retain
@@ -174,11 +177,13 @@ function reservePartialJSONParse(state, budget) {
 function captureStructuredJSONSnapshot(snapshot, property) {
     const descriptor = Object.getOwnPropertyDescriptor(snapshot, property);
     if (!descriptor) {
+        // SAFETY: Object.getPrototypeOf returns an object or null; the following traversal checks inherited properties without assuming a specific prototype type.
         let prototype = Object.getPrototypeOf(snapshot);
         for (let depth = 0; prototype !== null; depth += 1) {
             if (depth >= MAX_PARTIAL_JSON_DEPTH || Object.getOwnPropertyDescriptor(prototype, property)) {
                 throw new OpenAIError('Chat completion stream contains an unsafe structured JSON snapshot');
             }
+            // SAFETY: Object.getPrototypeOf returns an object or null; the following traversal checks inherited properties without assuming a specific prototype type.
             prototype = Object.getPrototypeOf(prototype);
         }
         return undefined;
@@ -187,6 +192,7 @@ function captureStructuredJSONSnapshot(snapshot, property) {
         (typeof descriptor.value !== 'string' && descriptor.value !== null && descriptor.value !== undefined)) {
         throw new OpenAIError('Chat completion stream contains an unsafe structured JSON snapshot');
     }
+    // SAFETY: The own data descriptor was explicitly checked to contain only a string, null, or undefined.
     return descriptor.value;
 }
 function captureStructuredMessageSnapshot(choice) {
@@ -197,16 +203,19 @@ function captureStructuredMessageSnapshot(choice) {
         descriptor.value === null) {
         throw new OpenAIError('Chat completion stream contains an unsafe structured JSON snapshot');
     }
+    // SAFETY: The choice contract supplies a message; the own data descriptor check prevents getters from changing which object is captured.
     return descriptor.value;
 }
 function captureSnapshotArray(snapshot, property, maximum, kind) {
     const descriptor = Object.getOwnPropertyDescriptor(snapshot, property);
     if (!descriptor) {
+        // SAFETY: Object.getPrototypeOf returns an object or null; the following traversal checks inherited properties without assuming a specific prototype type.
         let prototype = Object.getPrototypeOf(snapshot);
         for (let depth = 0; prototype !== null; depth += 1) {
             if (depth >= MAX_PARTIAL_JSON_DEPTH || Object.getOwnPropertyDescriptor(prototype, property)) {
                 throw new OpenAIError(`Chat completion stream contains an unsafe snapshot ${kind} collection`);
             }
+            // SAFETY: Object.getPrototypeOf returns an object or null; the following traversal checks inherited properties without assuming a specific prototype type.
             prototype = Object.getPrototypeOf(prototype);
         }
         return undefined;
@@ -218,6 +227,7 @@ function captureSnapshotArray(snapshot, property, maximum, kind) {
     if (!length || !('value' in length) || !Number.isSafeInteger(length.value) || length.value > maximum) {
         throw new OpenAIError(`Chat completion stream exceeded its snapshot ${kind} limit`);
     }
+    // SAFETY: The captured data property is an array with a checked bounded length; Item comes from the owning snapshot collection's contract.
     return descriptor.value;
 }
 function captureSnapshotArrayItem(array, index) {
@@ -228,6 +238,7 @@ function captureSnapshotArrayItem(array, index) {
     if (!('value' in descriptor)) {
         throw new OpenAIError('Chat completion stream contains an unsafe structured JSON snapshot');
     }
+    // SAFETY: The descriptor is a data property of the typed Item array, so its value retains that array's element contract.
     return descriptor.value;
 }
 function mapCapturedSnapshotArray(array, maximum, kind, map) {
@@ -246,6 +257,7 @@ function mapCapturedSnapshotArray(array, maximum, kind, map) {
         if (!('value' in item)) {
             throw new OpenAIError('Chat completion stream contains an unsafe structured JSON snapshot');
         }
+        // SAFETY: The descriptor is a data property of the typed Item array, so its value retains that array's element contract.
         mapped[index] = map(item.value, index);
     }
     return mapped;
@@ -280,6 +292,7 @@ function assertBoundToolCallIdentity(toolCall, identity) {
         throw new OpenAIError('Chat completion stream contains a changed tool call identity');
     }
 }
+// oxlint-disable-next-line anti-slop/no-object-parameters -- This assignment primitive copies own properties from heterogeneous snapshot and delta objects.
 function assignOwnProperties(target, source) {
     if (Object.prototype.propertyIsEnumerable.call(source, '__proto__') && !hasOwn(target, '__proto__')) {
         Object.defineProperty(target, '__proto__', {
@@ -299,12 +312,14 @@ function cloneParserConfigObject(value, stableFields = []) {
             continue;
         }
         descriptors[field] = {
+            // oxlint-disable-next-line anti-slop/no-reflect-get -- Generic config cloning must resolve inherited/accessor keys outside the declared config shape.
             value: descriptor && 'value' in descriptor ? descriptor.value : Reflect.get(value, field, value),
             enumerable: descriptor?.enumerable ?? false,
             configurable: descriptor?.configurable ?? true,
             writable: descriptor && 'writable' in descriptor ? descriptor.writable : false,
         };
     }
+    // SAFETY: The clone preserves the original prototype and descriptors, replacing only the parser metadata captured from that same value.
     return Object.create(Object.getPrototypeOf(value), descriptors);
 }
 function snapshotChatCompletionParserParams(params) {
@@ -322,6 +337,7 @@ function snapshotChatCompletionParserParams(params) {
                 stableTools.length = index + 1;
                 continue;
             }
+            // SAFETY: This own data descriptor comes from the request's typed tools array; the following code captures its parser metadata.
             const tool = item.value;
             const stableTool = cloneParserConfigObject(tool, [
                 'type',
@@ -340,6 +356,7 @@ function snapshotChatCompletionParserParams(params) {
                     value: cloneParserConfigObject(stableTool.function, ['name', 'strict']),
                 };
             }
+            // SAFETY: The cloned tool retains the original prototype and descriptors while substituting its captured parser configuration.
             stableTools[index] = Object.create(Object.getPrototypeOf(tool), descriptors);
         }
         snapshot.tools = stableTools;
@@ -370,6 +387,7 @@ function canonicalSerializedParserSchema(value, budget) {
         budget.bytes += bytes;
         return true;
     };
+    // SAFETY: Object.getPrototypeOf returns an object or null; the following traversal checks inherited properties without assuming a specific prototype type.
     const visit = (current, depth) => {
         if (depth > MAX_SERIALIZED_PARSER_SCHEMA_DEPTH || budget.nodes >= MAX_SERIALIZED_PARSER_SCHEMA_NODES) {
             return UNSAFE_SERIALIZED_PARSER_VALUE;
@@ -397,6 +415,7 @@ function canonicalSerializedParserSchema(value, budget) {
             return UNSAFE_SERIALIZED_PARSER_VALUE;
         }
         const array = Array.isArray(current);
+        // SAFETY: Object.getPrototypeOf returns an object or null; the following traversal checks inherited properties without assuming a specific prototype type.
         const prototype = Object.getPrototypeOf(current);
         if ((array && prototype !== Array.prototype) ||
             (!array && prototype !== null && prototype !== Object.prototype)) {
@@ -508,7 +527,11 @@ function canonicalSerializedParserSchema(value, budget) {
         return undefined;
     }
 }
-function rememberSerializedParserSchema(signatures, source, holder, key) {
+function rememberSerializedParserSchema(signatures, 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Parser owners are tracked by identity before their metadata descriptors are validated.
+source, 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Serialized schema holders may be arbitrary objects with hostile accessors or prototypes.
+holder, key) {
     const parser = Object.getOwnPropertyDescriptor(source, '$parseRaw');
     const schema = Object.getOwnPropertyDescriptor(holder, key);
     if (!parser ||
@@ -523,7 +546,11 @@ function rememberSerializedParserSchema(signatures, source, holder, key) {
         signatures.set(source, normalized);
     }
 }
-function hasMatchingSerializedParserSchema(signatures, source, holder, key, value) {
+function hasMatchingSerializedParserSchema(signatures, 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Parser signatures belong to the original object identity, independent of its fields.
+source, 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- The schema holder is inspected through own descriptors before its contents are trusted.
+holder, key, value) {
     const expected = source && signatures.get(source);
     const descriptor = Object.getOwnPropertyDescriptor(holder, key);
     return (expected !== undefined &&
@@ -554,6 +581,7 @@ function shadowSerializedParserMetadata(descriptors, source, fields) {
     }
 }
 function snapshotSerializedParserTool(serialized) {
+    // SAFETY: The fallback is a serialization scaffold: the code below installs the captured wire fields before the tool is returned.
     const source = serialized.source ??
         {
             type: serialized.type,
@@ -566,9 +594,11 @@ function snapshotSerializedParserTool(serialized) {
             descriptors.function = serializedParserDescriptor(descriptors.function, undefined);
         }
         shadowSerializedParserMetadata(descriptors, source, ['$brand', '$parseRaw', '$callback']);
+        // SAFETY: The descriptors reconstruct the tool's captured serialized fields and shadow parser metadata while retaining its original prototype.
         return Object.create(Object.getPrototypeOf(source), descriptors);
     }
     const descriptor = descriptors.function;
+    // SAFETY: The preceding guard proves this data descriptor contains a non-null object; no more specific type is assumed.
     const original = descriptor && 'value' in descriptor && typeof descriptor.value === 'object' && descriptor.value !== null
         ? descriptor.value
         : {};
@@ -579,17 +609,21 @@ function snapshotSerializedParserTool(serialized) {
     if (!serialized.function.schemaMatches) {
         shadowSerializedParserMetadata(descriptors, source, ['$brand', '$parseRaw', '$callback']);
     }
+    // SAFETY: The descriptors reconstruct the tool's captured serialized fields and shadow parser metadata while retaining its original prototype.
     return Object.create(Object.getPrototypeOf(source), descriptors);
 }
 function snapshotSerializedResponseFormat(serialized) {
+    // SAFETY: The fallback seeds only the discriminator; the captured response-format fields are installed below before returning it.
     const source = serialized.source ?? { type: serialized.type };
     const descriptors = Object.getOwnPropertyDescriptors(source);
     descriptors.type = serializedParserDescriptor(descriptors.type, serialized.type);
     if (serialized.type !== 'json_schema' || !serialized.source || !serialized.schemaMatches) {
         shadowSerializedParserMetadata(descriptors, source, ['$brand', '$parseRaw']);
     }
+    // SAFETY: The descriptors restore the captured response-format fields and parser metadata on the original prototype.
     return Object.create(Object.getPrototypeOf(source), descriptors);
 }
+// oxlint-disable-next-line anti-slop/no-object-parameters -- The serialization visitor accepts arbitrary object and array holders, inspecting own descriptors only.
 function ownSerializedParserObject(holder, key) {
     const descriptor = Object.getOwnPropertyDescriptor(holder, key);
     if (!descriptor || !('value' in descriptor)) {
@@ -655,6 +689,8 @@ function observeSerializedChatCompletionParserParams(body, initial, update) {
                 if (Array.isArray(value)) {
                     tools = new Proxy(value, {
                         get(target, property) {
+                            // SAFETY: Proxy property values may be arbitrary; unknown preserves that uncertainty before the property-specific checks below.
+                            // oxlint-disable-next-line anti-slop/no-reflect-get -- Proxy forwarding must preserve arbitrary keys with the original target as accessor receiver.
                             const actual = Reflect.get(target, property, target);
                             if (typeof property === 'string') {
                                 const index = Number(property);
@@ -766,6 +802,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
         super();
         _ChatCompletionStream_instances.add(this);
         _ChatCompletionStream_params.set(this, void 0);
+        _ChatCompletionStream_rejectsUnfinishedTurns.set(this, false);
         _ChatCompletionStream_audioDoneChoiceIndexes.set(this, void 0);
         _ChatCompletionStream_choiceEventStates.set(this, void 0);
         _ChatCompletionStream_currentChatCompletionSnapshot.set(this, void 0);
@@ -784,6 +821,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
                 if (!descriptor || !('value' in descriptor)) {
                     continue;
                 }
+                // SAFETY: The descriptor is read from the typed request tools array and checked as an own data property before accessing the tool.
                 const tool = descriptor.value;
                 if (isChatCompletionFunctionTool(tool) &&
                     (isAutoParsableTool(tool) || tool.function.strict === true)) {
@@ -812,10 +850,16 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
     }
     /** Starts a streaming chat completion request and returns its event-driven helper. */
     static createChatCompletion(client, params, options) {
+        // SAFETY: The runner forces stream: true when sending this request; the same parameters retain the caller's parsing configuration.
         const runner = new ChatCompletionStream(params);
         runner._run(() => runner._runChatCompletion(client, { ...params, stream: true }, { ...options, __metadata: { ...options?.__metadata, helperMethod: 'stream' } }));
         return runner;
     }
+    /** Rejects unfinished turns before tool callbacks while preserving ordinary stream and replay behavior. */
+    _runTools(client, params, runner, options) {
+        __classPrivateFieldSet(this, _ChatCompletionStream_rejectsUnfinishedTurns, true, "f");
+        return super._runTools(client, params, runner, options);
+    }
     async _createChatCompletion(client, params, options) {
         this._listenForAbort(options?.signal);
         const requestParams = { ...params, stream: true };
@@ -842,7 +886,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
             __classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_addChunk).call(this, chunk);
         }
         if (stream.controller.signal?.aborted) {
-            throw new APIUserAbortError();
+            throw this._userAbortError();
         }
         return this._addChatCompletion(__classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_endRequest).call(this));
     }
@@ -883,7 +927,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
             }
         }
         if (stream.controller.signal?.aborted) {
-            throw new APIUserAbortError();
+            throw this._userAbortError();
         }
         if (__classPrivateFieldGet(this, _ChatCompletionStream_currentChatCompletionSnapshot, "f")) {
             return this._addChatCompletion(__classPrivateFieldGet(this, _ChatCompletionStream_instances, "m", _ChatCompletionStream_endRequest).call(this));
@@ -895,7 +939,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
         throw new OpenAIError(`request ended without sending any chunks`);
     }
     /** Iterates over raw API chunks; stopping iteration early aborts the underlying request. */
-    [(_ChatCompletionStream_params = new WeakMap(), _ChatCompletionStream_audioDoneChoiceIndexes = new WeakMap(), _ChatCompletionStream_choiceEventStates = new WeakMap(), _ChatCompletionStream_currentChatCompletionSnapshot = new WeakMap(), _ChatCompletionStream_hasAutoParseableTool = new WeakMap(), _ChatCompletionStream_partialJSONParseBudget = new WeakMap(), _ChatCompletionStream_instances = new WeakSet(), _ChatCompletionStream_beginRequest = function _ChatCompletionStream_beginRequest() {
+    [(_ChatCompletionStream_params = new WeakMap(), _ChatCompletionStream_rejectsUnfinishedTurns = new WeakMap(), _ChatCompletionStream_audioDoneChoiceIndexes = new WeakMap(), _ChatCompletionStream_choiceEventStates = new WeakMap(), _ChatCompletionStream_currentChatCompletionSnapshot = new WeakMap(), _ChatCompletionStream_hasAutoParseableTool = new WeakMap(), _ChatCompletionStream_partialJSONParseBudget = new WeakMap(), _ChatCompletionStream_instances = new WeakSet(), _ChatCompletionStream_beginRequest = function _ChatCompletionStream_beginRequest() {
         if (this.ended) {
             return;
         }
@@ -1039,7 +1083,9 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
             throw new Error('tool call snapshot missing `type`');
         }
         if (toolCallSnapshot.type === 'function') {
+            // SAFETY: The find predicate verifies the function-tool discriminator before matching its name; the cast carries that refinement through find.
             const inputTool = __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.tools?.find((tool) => isChatCompletionFunctionTool(tool) && tool.function.name === toolCallSnapshot.function.name); // TS doesn't narrow based on isChatCompletionTool
+            // oxlint-disable-next-line anti-slop/no-known-value-widening -- The initial null is replaced with an arbitrary tool-parser result after snapshot validation.
             let parsedArguments = null;
             const parseable = isAutoParsableTool(inputTool) || inputTool?.function.strict === true;
             let argumentsSnapshot;
@@ -1191,6 +1237,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
                 if (!descriptor || !('value' in descriptor)) {
                     throw new OpenAIError('Chat completion stream contains an unsafe structured JSON snapshot');
                 }
+                // SAFETY: The tool-call function is captured through an own data descriptor; its fields are subsequently checked by the structured snapshot reader.
                 const fn = descriptor.value;
                 const argumentsSnapshot = captureStructuredJSONSnapshot(fn, 'arguments');
                 if (typeof argumentsSnapshot !== 'string') {
@@ -1284,7 +1331,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
             }
             if (finish_reason) {
                 choice.finish_reason = finish_reason;
-                if (__classPrivateFieldGet(this, _ChatCompletionStream_params, "f") && hasAutoParseableInput(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f"))) {
+                if (__classPrivateFieldGet(this, _ChatCompletionStream_params, "f") && (__classPrivateFieldGet(this, _ChatCompletionStream_rejectsUnfinishedTurns, "f") || hasAutoParseableInput(__classPrivateFieldGet(this, _ChatCompletionStream_params, "f")))) {
                     if (finish_reason === 'length') {
                         throw new LengthFinishReasonError();
                     }
@@ -1299,6 +1346,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
                 continue;
             } // Shouldn't happen; just in case.
             __classPrivateFieldGet(this, _ChatCompletionStream_audioDoneChoiceIndexes, "f").delete(index);
+            // SAFETY: Streaming audio fields arrive incrementally even though the generated delta type omits them; each present field is merged below.
             const { audio, content, refusal, function_call, role, ...capturedDeltaFields } = delta;
             const { tool_calls: capturedToolCallDelta, ...rest } = capturedDeltaFields;
             const tool_calls = hasOwn(capturedDeltaFields, 'tool_calls') ? capturedToolCallDelta : delta.tool_calls;
@@ -1378,6 +1426,7 @@ export class ChatCompletionStream extends AbstractChatCompletionRunner {
                 // Tool calls are built up across chunks, so while the stream is in progress the
                 // entries are only partially filled in; they match `ChatCompletionSnapshot.Choice.Message.ToolCall`
                 // once every delta for them has been accumulated.
+                // SAFETY: This SDK-owned collection holds partial tool calls during accumulation; finalization checks required fields before exposing completed calls.
                 const toolCallSnapshots = ((_e = choice.message).tool_calls ?? (_e.tool_calls = []));
                 for (const toolCallDelta of tool_calls) {
                     const { index, id, type, function: fn, custom, ...rest } = toolCallDelta;
@@ -1503,6 +1552,7 @@ function finalizeChatCompletion(snapshot, params, audioDoneChoiceIndexes, valida
             }
             const stableChoice = new Proxy(choice, {
                 get(target, property, receiver) {
+                    // oxlint-disable-next-line anti-slop/no-reflect-get -- Proxy forwarding must preserve arbitrary keys and the original accessor receiver.
                     return property === 'message' ? validated.message : Reflect.get(target, property, receiver);
                 },
             });
@@ -1518,6 +1568,7 @@ function finalizeChatCompletion(snapshot, params, audioDoneChoiceIndexes, valida
                     if (property === 'tool_calls') {
                         return validated.toolCallCollection;
                     }
+                    // oxlint-disable-next-line anti-slop/no-reflect-get -- Proxy forwarding must preserve arbitrary keys and the original accessor receiver.
                     return Reflect.get(target, property, receiver);
                 },
             });
@@ -1528,7 +1579,9 @@ function finalizeChatCompletion(snapshot, params, audioDoneChoiceIndexes, valida
             if (!finishReason) {
                 throw new OpenAIError(`missing finish_reason for choice ${index}`);
             }
+            // SAFETY: The completed API response contract supplies the audio fields; this preserves the existing pass-through behavior at finalization.
             const audioResponse = audio ? { audio: audio } : {};
+            // SAFETY: The API completion contract uses assistant role; retaining the wire role preserves existing behavior without adding runtime rejection.
             const role = message.role; // this is what we expect; in theory it could be different which would make our types a slight lie but would be fine.
             if (!role) {
                 throw new OpenAIError(`missing role for choice ${index}`);
@@ -1591,6 +1644,7 @@ function finalizeChatCompletion(snapshot, params, audioDoneChoiceIndexes, valida
                                         if (property === 'name') {
                                             return captured.name;
                                         }
+                                        // oxlint-disable-next-line anti-slop/no-reflect-get -- Proxy forwarding must preserve arbitrary keys and the original accessor receiver.
                                         return Reflect.get(target, property, receiver);
                                     },
                                 });
@@ -1603,6 +1657,7 @@ function finalizeChatCompletion(snapshot, params, audioDoneChoiceIndexes, valida
                                         if (property === 'function') {
                                             return stableFunction;
                                         }
+                                        // oxlint-disable-next-line anti-slop/no-reflect-get -- Proxy forwarding must preserve arbitrary keys and the original accessor receiver.
                                         return Reflect.get(target, property, receiver);
                                     },
                                 })
@@ -1652,6 +1707,7 @@ function finalizeChatCompletion(snapshot, params, audioDoneChoiceIndexes, valida
         created,
         model,
         object: 'chat.completion',
+        // Spread creates an own data property without invoking inherited setters or changing the object prototype.
         ...(system_fingerprint ? { system_fingerprint } : {}),
     };
     return maybeParseChatCompletion(completion, params);