diff --git a/packages/ai/src/decision-client.ts b/packages/ai/src/decision-client.ts index f8f6edee28b..188038f5f83 100644 --- a/packages/ai/src/decision-client.ts +++ b/packages/ai/src/decision-client.ts @@ -33,10 +33,7 @@ export const layer: Layer.Layer = 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 return yield* new AIError({ diff --git a/packages/ai/src/media-client.ts b/packages/ai/src/media-client.ts index d5745413b0d..622bfa7fdba 100644 --- a/packages/ai/src/media-client.ts +++ b/packages/ai/src/media-client.ts @@ -31,7 +31,6 @@ export const make = , 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, operation: string) => new AIError({ reason: new UnsupportedOperationError({ @@ -44,29 +43,27 @@ export const make = , 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)) }, }) }), diff --git a/packages/ai/src/protocols/utils/responses-compaction.ts b/packages/ai/src/protocols/utils/responses-compaction.ts index d276e5246ec..3500019b7b0 100644 --- a/packages/ai/src/protocols/utils/responses-compaction.ts +++ b/packages/ai/src/protocols/utils/responses-compaction.ts @@ -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, diff --git a/packages/ai/src/route/client.ts b/packages/ai/src/route/client.ts index 34c87af5528..9781477d8f4 100644 --- a/packages/ai/src/route/client.ts +++ b/packages/ai/src/route/client.ts @@ -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 = Layer ): Effect.Effect function compact(request: LLMRequest, options?: EndpointCompactOptions | TriggerCompactOptions) { return Effect.suspend((): Effect.Effect => { - 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) }) } diff --git a/packages/ai/src/route/executor.ts b/packages/ai/src/route/executor.ts index cfd75cd49e9..51c789a8d14 100644 --- a/packages/ai/src/route/executor.ts +++ b/packages/ai/src/route/executor.ts @@ -261,7 +261,10 @@ export const layer: Layer.Layer = 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 diff --git a/packages/ai/src/route/media.ts b/packages/ai/src/route/media.ts index 17f04061959..c46cca43152 100644 --- a/packages/ai/src/route/media.ts +++ b/packages/ai/src/route/media.ts @@ -334,7 +334,7 @@ const makeTransport = ( 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 = ( 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 = { diff --git a/packages/ai/src/route/transport/http.ts b/packages/ai/src/route/transport/http.ts index 7924bbf02b3..daca308c631 100644 --- a/packages/ai/src/route/transport/http.ts +++ b/packages/ai/src/route/transport/http.ts @@ -109,7 +109,10 @@ export const httpJson = (input: HttpJsonInput): 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"),