fix(ai): attach the client certificate where provider requests are sent, not to in-route downloads

This commit is contained in:
Aiden Cline
2026-11-08 01:17:09 -06:00
Unverified
parent d98ccadc0e
commit cc4b6e4f7e
7 changed files with 24 additions and 25 deletions
+1 -4
View File
@@ -33,10 +33,7 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
return Service.of({
generate: Effect.fnUntraced(function* (request) {
const route = request.model.route
const response = yield* route.generate(
request,
RequestExecutor.withTls(executor.execute, request.model.http?.tls),
)
const response = yield* route.generate(request, executor.execute)
if (answersMatch(request.questions, response.answers))
return response as DecisionResponseFor<typeof request.questions>
return yield* new AIError({
+5 -8
View File
@@ -31,7 +31,6 @@ export const make = <Self, Req extends RoutedRequest<Req, Event, Response>, Even
service,
Effect.gen(function* () {
const executor = yield* RequestExecutor.Service
const execute = (model: Req["model"]) => RequestExecutor.withTls(executor.execute, model.http?.tls)
const notQueued = (route: MediaRoute.AnyRoute<Req, Event, Response>, operation: string) =>
new AIError({
reason: new UnsupportedOperationError({
@@ -44,29 +43,27 @@ export const make = <Self, Req extends RoutedRequest<Req, Event, Response>, Even
const start = (request: Req) => {
const route = request.model.route
if (route.kind !== "queued") return Effect.fail(notQueued(route, "start"))
return route.start(request, execute(request.model))
return route.start(request, executor.execute)
}
return service.of({
start,
resume: (model, token) => {
if (model.route.kind !== "queued") return Effect.fail(notQueued(model.route, "resume"))
return model.route.resume(model, token, execute(model))
return model.route.resume(model, token, executor.execute)
},
generate: (request, options) => {
const route = request.model.route
if (route.kind !== "queued") return route.generate(request, execute(request.model))
if (route.kind !== "queued") return route.generate(request, executor.execute)
return start(request).pipe(Effect.flatMap((generation) => generation.await(options)))
},
stream: (request, options) => {
const route = request.model.route
if (route.kind === "stream") return route.stream(request, execute(request.model))
if (route.kind === "stream") return route.stream(request, executor.execute)
if (route.kind === "queued")
return Stream.unwrap(
start(request).pipe(Effect.map((generation) => resultEvents(generation, input.responseEvents, options))),
)
return Stream.fromIterableEffect(
Effect.map(route.generate(request, execute(request.model)), input.responseEvents),
)
return Stream.fromIterableEffect(Effect.map(route.generate(request, executor.execute), input.responseEvents))
},
})
}),
@@ -117,7 +117,7 @@ export const make = (
auth: route.auth,
encodeBody: Schema.encodeSync(Schema.fromJsonString(Body)),
})
const response = yield* executor.execute(
const response = yield* RequestExecutor.withTls(executor.execute, request.http?.tls)(
ProviderShared.jsonPost({
url: parts.url,
body: parts.bodyText,
+3 -6
View File
@@ -608,8 +608,7 @@ const streamRequestWith = (runtime: TransportRuntime) => (request: LLMRequest, o
Stream.unwrap(
Effect.gen(function* () {
const compiled = yield* compile(request, options)
const http = { execute: RequestExecutor.withTls(runtime.http.execute, compiled.request.http?.tls) }
return compiled.route.streamPrepared(compiled.prepared, compiled.request, { http }, options)
return compiled.route.streamPrepared(compiled.prepared, compiled.request, runtime, options)
}),
)
@@ -671,12 +670,10 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
): Effect.Effect<CompactionResponse, AIError>
function compact(request: LLMRequest, options?: EndpointCompactOptions | TriggerCompactOptions) {
return Effect.suspend((): Effect.Effect<CompactionResponse | CompactionCheckpointResponse, AIError> => {
const prepared = prepareRequest(request)
const http = { execute: RequestExecutor.withTls(executor.execute, prepared.http?.tls) }
if (options?.mechanism === "trigger" && canCompact(request, options))
return request.model.route.compact.trigger(prepared, http, options)
return request.model.route.compact.trigger(prepareRequest(request), executor, options)
if ((options?.mechanism === undefined || options.mechanism === "endpoint") && canCompact(request))
return request.model.route.compact.endpoint(prepared, http, options)
return request.model.route.compact.endpoint(prepareRequest(request), executor, options)
return unsupportedCompaction(request.model, options?.mechanism)
})
}
+4 -1
View File
@@ -261,7 +261,10 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
export const fetchLayer = layer.pipe(Layer.provide(FetchHttpClient.layer))
/** Sends through `execute`, presenting `tls` on each request. The executor's HTTP client reads it from `CurrentTls`. */
/**
* Sends through `execute`, presenting `tls` on each request. Apply it only where a provider request is sent, so
* downloads made through the plain executor never carry the certificate. The executor's HTTP client reads `CurrentTls`.
*/
export const withTls = (execute: Interface["execute"], tls: ClientTls | undefined): Interface["execute"] =>
tls ? (request, middleware) => execute(request, middleware).pipe(Effect.provideService(CurrentTls, tls)) : execute
+6 -4
View File
@@ -334,7 +334,7 @@ const makeTransport = <Request extends MediaRequest>(
body: encoded.text,
headers: encoded.headers,
})
const response = yield* execute(
const response = yield* RequestExecutor.withTls(execute, call.request.http?.tls)(
encoded.apply(HttpClientRequest.make(call.method)(url).pipe(HttpClientRequest.setHeaders(headers))),
RequestExecutor.withFetch(fetch),
)
@@ -365,9 +365,11 @@ const makeTransport = <Request extends MediaRequest>(
protocol.prepare === undefined
? request
: yield* protocol.prepare(request, (path, body) =>
send({ method: "POST", url: baseURL(path), headers, request, body }, request.fetch, execute).pipe(
Effect.map((sent) => sent.response),
),
send(
{ method: "POST", url: baseURL(path), headers, request: { ...request, http }, body },
request.fetch,
execute,
).pipe(Effect.map((sent) => sent.response)),
)
// Sanitize after merging so model-level overlays are covered; the model value is restored, not sanitized.
const resolved: Request = {
+4 -1
View File
@@ -109,7 +109,10 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
const limits = timeoutConfig(request.timeout)
// Unlike the header and chunk limits, the whole-request budget has no default.
const total = limits.total ? Duration.millis(limits.total) : Duration.infinity
const response = yield* runtime.http.execute(prepared.request, prepared.middleware).pipe(
const response = yield* RequestExecutor.withTls(runtime.http.execute, request.http?.tls)(
prepared.request,
prepared.middleware,
).pipe(
Effect.timeoutOrElse({
duration: Duration.min(timeoutDuration(limits.headers), total),
orElse: () => timeout("request", "Timed out waiting for response headers"),