internal/server/handlers_test.go (2)

761-833: 🧹 Nitpick | 🔵 Trivial

Test name inconsistency with new naming convention.

The test function TestChatCompletion_UsesIngressFrameForDecoding still references the old "IngressFrame" terminology while the implementation now uses NewRequestSnapshot. Consider renaming to TestChatCompletion_UsesRequestSnapshotForDecoding for consistency with the refactor.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/handlers_test.go` around lines 761 - 833, Rename the test
function TestChatCompletion_UsesIngressFrameForDecoding to use the new naming
convention (e.g., TestChatCompletion_UsesRequestSnapshotForDecoding) so it
matches the refactor that replaced "IngressFrame" with NewRequestSnapshot;
update the test function identifier and any references to the old name (in this
file's test definition) to the new name, leaving the test body and assertions
(provider, frame creation via core.NewRequestSnapshot, and semantics checks)
unchanged.

---

915-982: 🧹 Nitpick | 🔵 Trivial

Test names reference old terminology.

Similar to the chat completions test, these test functions still reference "IngressFrame" in their names:

• TestResponses_UsesIngressFrameForDecoding (Line 915)
• TestEmbeddings_UsesIngressFrameForDecoding (Line 984)
• TestBatches_UsesIngressFrameForDecoding (Line 1050)
• TestGetBatch_UsesSemanticEnvelopeRouteMetadata (Line 1130)
• TestListBatches_UsesSemanticEnvelopeQueryMetadata (Line 1176)

Consider renaming these to use "RequestSnapshot" and "RequestSemantics" terminology for consistency. The implementation code itself is correct.

Also applies to: 984-1048, 1050-1128, 1130-1174

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/handlers_test.go` around lines 915 - 982, Rename the tests
that still reference old "IngressFrame" terminology to use "RequestSnapshot" and
"RequestSemantics" as suggested: change
TestResponses_UsesIngressFrameForDecoding ->
TestResponses_UsesRequestSnapshotForDecoding,
TestEmbeddings_UsesIngressFrameForDecoding ->
TestEmbeddings_UsesRequestSnapshotForDecoding,
TestBatches_UsesIngressFrameForDecoding ->
TestBatches_UsesRequestSnapshotForDecoding,
TestGetBatch_UsesSemanticEnvelopeRouteMetadata ->
TestGetBatch_UsesRequestSemanticsRouteMetadata, and
TestListBatches_UsesSemanticEnvelopeQueryMetadata ->
TestListBatches_UsesRequestSemanticsQueryMetadata; update the function names and
any internal references/calls to those symbols (test function identifiers and
any t.Run strings or comments) so names are consistent while leaving test logic
unchanged.

internal/server/semantic_requests_test.go (8)

230-257: 🧹 Nitpick | 🔵 Trivial

Test function name inconsistency: TestFileRequestFromSemanticEnvelope_InvalidLimitFromIngressReturnsError.

Consider renaming to TestFileRouteInfoFromSemantics_InvalidLimitReturnsError. "Ingress" terminology could be updated to "Snapshot" or removed.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 230 - 257, Rename the
test function
TestFileRequestFromSemanticEnvelope_InvalidLimitFromIngressReturnsError to
TestFileRouteInfoFromSemantics_InvalidLimitReturnsError to match naming
conventions and the function under test (fileRouteInfoFromSemantics); update the
test function declaration accordingly and any references to it so the name no
longer uses "Ingress" or "Envelope" and instead reflects
"RouteInfoFromSemantics" and "InvalidLimit".

---

109-137: 🧹 Nitpick | 🔵 Trivial

Test function name inconsistency: TestCanonicalJSONRequestFromSemanticEnvelope_FallsBackToLiveBodyWhenIngressBodyMissing.

Consider renaming to use "Semantics" instead of "SemanticEnvelope". The phrase "IngressBody" could also be updated to "SnapshotBody" or "CapturedBody" for full consistency.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 109 - 137, Rename the
test function
TestCanonicalJSONRequestFromSemanticEnvelope_FallsBackToLiveBodyWhenIngressBodyMissing
to use consistent terminology (e.g.,
TestCanonicalJSONRequestFromSemantics_FallsBackToSnapshotBodyWhenIngressBodyMissing
or
TestCanonicalJSONRequestFromSemantics_FallsBackToCapturedBodyWhenSnapshotMissing);
update the function declaration and any references to it (test name strings,
usages in other tests or CI configurations) and ensure the new name still
follows Go test naming conventions and matches the intent in
canonicalJSONRequestFromSemantics and core.RequestSnapshot/ingress terminology.

---

18-61: 🧹 Nitpick | 🔵 Trivial

Test function name still references old terminology.

The test function is named TestCanonicalJSONRequestFromSemanticEnvelope_CachesChatRequest but the implementation now uses RequestSemantics. Consider renaming to TestCanonicalJSONRequestFromSemantics_CachesChatRequest for consistency with the internal helper rename (canonicalJSONRequestFromSemantics).

The internal logic correctly uses the new types and field names (RequestSnapshot, RequestSemantics, RoutingHints).

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 18 - 61, Rename the
test function to match the updated terminology: change
TestCanonicalJSONRequestFromSemanticEnvelope_CachesChatRequest to
TestCanonicalJSONRequestFromSemantics_CachesChatRequest so it aligns with the
helper canonicalJSONRequestFromSemantics and the new RequestSemantics types;
update any references or comments in the file that mention "SemanticEnvelope" to
"Semantics" and ensure the test still asserts env.CachedChatRequest(),
GetRequestSemantics, and RoutingHints behavior unchanged.

---

299-338: 🧹 Nitpick | 🔵 Trivial

Test function name inconsistency: TestFileRequestFromSemanticEnvelope_CachesListMetadata.

Consider renaming to TestFileRouteInfoFromSemantics_CachesListMetadata. The internal implementation correctly uses new terminology.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 299 - 338, Rename the
test function TestFileRequestFromSemanticEnvelope_CachesListMetadata to
TestFileRouteInfoFromSemantics_CachesListMetadata to match the new terminology;
update the test declaration (the func name) and any references to it, keeping
the test body and assertions intact (the test uses fileRouteInfoFromSemantics,
core.FileActionList, and related fields like Provider, Purpose, After, HasLimit,
Limit).

---

189-228: 🧹 Nitpick | 🔵 Trivial

Test function name inconsistency: TestBatchRequestMetadataFromSemanticEnvelope_CachesListMetadata.

Consider renaming to TestBatchRouteInfoFromSemantics_CachesListMetadata to align with the helper rename (batchRouteInfoFromSemantics) and the return type (BatchRouteInfo).

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 189 - 228, Rename the
test function TestBatchRequestMetadataFromSemanticEnvelope_CachesListMetadata to
TestBatchRouteInfoFromSemantics_CachesListMetadata so the name matches the
helper batchRouteInfoFromSemantics and the returned type BatchRouteInfo; update
the function declaration and any references to the old test name in the test
file to the new name to keep naming consistent.

---

259-297: 🧹 Nitpick | 🔵 Trivial

Test function name inconsistency: TestFileRequestFromSemanticEnvelope_EnrichesCreateMetadata.

Consider renaming to TestFileRouteInfoFromSemantics_EnrichesCreateMetadata. Internal logic correctly uses the new types.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 259 - 297, Rename the
test function TestFileRequestFromSemanticEnvelope_EnrichesCreateMetadata to
TestFileRouteInfoFromSemantics_EnrichesCreateMetadata; update the function
declaration and any references or test names so they match the new identifier,
ensuring it still calls fileRouteInfoFromSemantics, core.GetRequestSemantics,
and asserts on env.CachedFileRouteInfo() unchanged so the test compiles and runs
under the new name.

---

139-187: 🧹 Nitpick | 🔵 Trivial

Test function name inconsistency: TestCanonicalJSONRequestFromSemanticEnvelope_CachesBatchRequest.

Consider renaming to TestCanonicalJSONRequestFromSemantics_CachesBatchRequest. The internal logic is correct.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 139 - 187, Rename the
test function TestCanonicalJSONRequestFromSemanticEnvelope_CachesBatchRequest to
TestCanonicalJSONRequestFromSemantics_CachesBatchRequest to match naming
conventions; update the function declaration (the test func name) so callers and
test runner use the new name while leaving the body intact—the test still
exercises canonicalJSONRequestFromSemantics[*core.BatchRequest] and
env.CachedBatchRequest() behavior.

---

63-107: 🧹 Nitpick | 🔵 Trivial

Test function name inconsistency: TestCanonicalJSONRequestFromSemanticEnvelope_CachesResponsesRequest.

Same as above - consider renaming to align with the new terminology. The internal implementation is correct.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/semantic_requests_test.go` around lines 63 - 107, Rename the
test function to use the updated terminology: change
TestCanonicalJSONRequestFromSemanticEnvelope_CachesResponsesRequest to a name
like TestCanonicalJSONRequestFromSemantics_CachesResponsesRequest (or
TestCanonicalJSONRequestFromRequestSemantics_CachesResponsesRequest) so it
matches the implementation that calls canonicalJSONRequestFromSemantics and
core.DecodeResponsesRequest; update the test function declaration and any
references accordingly and re-run tests to ensure there are no remaining name
mismatches.

internal/core/semantic_test.go (1)

8-49: 🧹 Nitpick | 🔵 Trivial

Rename these core semantic tests to the new API surface.

The bodies now validate DeriveWhiteBoxPrompt, but the TestBuildSemanticEnvelope_* names still point grep results and failure output at removed terminology. The sibling cases in this file have the same drift.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/core/semantic_test.go` around lines 8 - 49, Rename the test
functions to reflect the new API surface: change
TestBuildSemanticEnvelope_OpenAICompat to TestDeriveWhiteBoxPrompt_OpenAICompat
(and similarly rename the other sibling TestBuildSemanticEnvelope_* tests in
this file) so their names match the function under test DeriveWhiteBoxPrompt;
update any references in test names and test failure messages if they still
mention "BuildSemanticEnvelope" to use "DeriveWhiteBoxPrompt" to keep
grep/failure output consistent with the current implementation.

internal/server/handlers_test.go (1)

789-807: 🧹 Nitpick | 🔵 Trivial

Extract the snapshot/prompt request setup into a test helper.

The NewRequestSnapshot → WithRequestSnapshot → WithWhiteBoxPrompt wiring is repeated throughout this file. A small helper will make the next context-shape or naming change much cheaper.

♻️ Possible helper

+func withSnapshotAndPrompt(req *http.Request, snapshot *core.RequestSnapshot) *http.Request {
+	ctx := core.WithRequestSnapshot(req.Context(), snapshot)
+	if prompt := core.DeriveWhiteBoxPrompt(snapshot); prompt != nil {
+		ctx = core.WithWhiteBoxPrompt(ctx, prompt)
+	}
+	return req.WithContext(ctx)
+}
...
-ctx := core.WithRequestSnapshot(req.Context(), frame)
-ctx = core.WithWhiteBoxPrompt(ctx, core.DeriveWhiteBoxPrompt(frame))
-req = req.WithContext(ctx)
+req = withSnapshotAndPrompt(req, frame)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/server/handlers_test.go` around lines 789 - 807, Extract the
repeated snapshot/prompt setup into a single test helper (e.g.,
makeTestRequestContext or buildSnapshotContext) that accepts the original
*http.Request or parameters and returns a context with core.NewRequestSnapshot,
core.WithRequestSnapshot and core.WithWhiteBoxPrompt applied (using
core.DeriveWhiteBoxPrompt). Replace each occurrence of the three-line sequence
in handlers_test.go with a call to this helper and update tests to use the
returned context (or req.WithContext) so callers no longer duplicate
NewRequestSnapshot, WithRequestSnapshot, WithWhiteBoxPrompt wiring.

internal/core/semantic.go (1)

239-278: 🧹 Nitpick | 🔵 Trivial

Finish the rename in the transport classifiers.

DeriveFileRouteInfoFromTransport and DeriveBatchRouteInfoFromTransport still depend on fileActionFromIngress / batchActionFromIngress, so the old term remains in the core route-derivation path. Renaming those helpers in the same sweep will keep grep/search and follow-up refactors consistent.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/core/semantic.go` around lines 239 - 278, The two transport-derived
helpers were partially renamed but callers still use fileActionFromIngress and
batchActionFromIngress; update the helpers and all call sites to the new names
(e.g., rename fileActionFromIngress -> fileActionFromTransport and
batchActionFromIngress -> batchActionFromTransport) and change the calls inside
DeriveFileRouteInfoFromTransport and DeriveBatchRouteInfoFromTransport
accordingly; ensure you also rename the function declarations, update any
imports/tests/other references to the old names, and run tests to confirm no
remaining references to the old identifiers remain.

internal/core/semantic.go (1)

239-279: 🧹 Nitpick | 🔵 Trivial

Deduplicate transport limit parsing to prevent drift between file and batch paths.

Lines 249-254 and Lines 269-274 repeat the same parsing block. A shared helper would reduce maintenance overhead and keep behavior consistent.

♻️ Suggested refactor

 func DeriveFileRouteInfoFromTransport(method, path string, routeParams map[string]string, queryParams map[string][]string) *FileRouteInfo {
 	req := &FileRouteInfo{
 		Action:   fileActionFromTransport(method, path),
 		Provider: firstTransportValue(queryParams, "provider"),
 		Purpose:  firstTransportValue(queryParams, "purpose"),
 		After:    firstTransportValue(queryParams, "after"),
 		LimitRaw: firstTransportValue(queryParams, "limit"),
 		FileID:   fileIDFromTransport(path, routeParams),
 	}
-	if req.LimitRaw != "" {
-		if parsed, err := strconv.Atoi(req.LimitRaw); err == nil {
-			req.Limit = parsed
-			req.HasLimit = true
-		}
-	}
+	req.Limit, req.HasLimit = parseTransportLimit(req.LimitRaw)
 	if req.Action == "" && req.Provider == "" && req.Purpose == "" && req.After == "" && req.LimitRaw == "" && req.FileID == "" {
 		return nil
 	}
 	return req
 }
 
 // DeriveBatchRouteInfoFromTransport derives sparse batch route info from transport metadata.
 func DeriveBatchRouteInfoFromTransport(method, path string, routeParams map[string]string, queryParams map[string][]string) *BatchRouteInfo {
 	req := &BatchRouteInfo{
 		Action:   batchActionFromTransport(method, path),
 		BatchID:  batchIDFromTransport(path, routeParams),
 		After:    firstTransportValue(queryParams, "after"),
 		LimitRaw: firstTransportValue(queryParams, "limit"),
 	}
-	if req.LimitRaw != "" {
-		if parsed, err := strconv.Atoi(req.LimitRaw); err == nil {
-			req.Limit = parsed
-			req.HasLimit = true
-		}
-	}
+	req.Limit, req.HasLimit = parseTransportLimit(req.LimitRaw)
 	if req.Action == "" && req.BatchID == "" && req.After == "" && req.LimitRaw == "" {
 		return nil
 	}
 	return req
 }
+
+func parseTransportLimit(raw string) (int, bool) {
+	if raw == "" {
+		return 0, false
+	}
+	parsed, err := strconv.Atoi(raw)
+	if err != nil {
+		return 0, false
+	}
+	return parsed, true
+}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/core/semantic.go` around lines 239 - 279, The repeated limit-parsing
logic in DeriveFileRouteInfoFromTransport and DeriveBatchRouteInfoFromTransport
should be pulled into a small helper (e.g., parseLimit or parseLimitFromRaw)
that accepts the LimitRaw string and returns (int, bool) or similar; replace the
duplicated blocks that set req.Limit and req.HasLimit with a single call to that
helper, and use the returned values to populate req.Limit and req.HasLimit for
both FileRouteInfo and BatchRouteInfo (refer to the LimitRaw, Limit, HasLimit
fields and the two functions named DeriveFileRouteInfoFromTransport and
DeriveBatchRouteInfoFromTransport).

internal/core/semantic_test.go (1)

169-250: 🧹 Nitpick | 🔵 Trivial

Consider updating legacy assertion labels for consistency.

A few failure messages still reference pre-rename labels (e.g., FileRequest, BatchMetadata). Updating those strings would improve debugging clarity during failures.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/core/semantic_test.go` around lines 169 - 250, Update the test
failure message strings to use the current, consistent labels instead of legacy
names: replace occurrences like "FileRequest = nil" and "FileRequest.Action"
with names matching CachedFileRouteInfo or FileRouteInfo, and replace
"BatchMetadata = nil" and "BatchMetadata.Action" with BatchRouteInfo or
CachedBatchRouteInfo in the tests (see
TestDeriveWhiteBoxPrompt_BatchesListMetadata,
TestDeriveWhiteBoxPrompt_BatchResultsMetadata and the earlier file-content test
that calls CachedFileRouteInfo); keep the validation logic and t.Fatal/t.Fatalf
calls but change only the human-readable strings to the new labels for
consistent debugging output.