@opencode/ai 0.0.0-dev-20115 → 0.0.0-dev-20116

package/dist/image-client.js

@@ -2,8 +2,9 @@ import { Context, Effect, Layer, Stream } from "effect";
 import { RequestExecutor } from "./route/executor.js";
 import { MediaRoute } from "./route/media.js";
 import { responseEvents, } from "./image.js";
-export class Service extends Context.Service()("@opencode/ImageClient") {
+export class ImageClientService extends Context.Service()("@opencode/ImageClient") {
 }
+export const Service = ImageClientService;
 export const generate = (request, options) => Effect.gen(function* () {
     const client = yield* Service;
     return yield* client.generate(request, options);

package/dist/index.d.ts

@@ -1,10 +1,11 @@
+export { AIClient } from "./ai-client.js";
 export { LLMClient } from "./route/client.js";
 export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";
 export { Provider } from "./provider.js";
 export { ProviderPackage } from "./provider-package.js";
 export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
-export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, Service as LLMClientService, } from "./route/client.js";
+export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, LLMClientService, } from "./route/client.js";
 export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
 export type { ImageFormat, ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute, } from "./image.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+export { AIClient } from "./ai-client.js";
 export { LLMClient } from "./route/client.js";
 export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";

package/dist/media.js

@@ -5,7 +5,7 @@ import { ProviderID } from "./schema/ids.js";
 import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js";
 import { ProviderMetadata } from "./schema/options.js";
 import { Service } from "./route/executor-service.js";
-import { detectMediaType, extensionMediaType } from "./utils/media-type.js";
+import { detectMediaType, fileMediaType } from "./utils/media-type.js";
 export { detectMediaType } from "./utils/media-type.js";
 const OCTET_STREAM = "application/octet-stream";
 // ---------------------------------------------------------------------------
@@ -215,7 +215,7 @@ export const file = (path, options) => Effect.gen(function* () {
     const data = yield* fs
         .readFile(path)
         .pipe(Effect.mapError((cause) => invalid(`Failed to read media file ${path}`, cause)));
-    return bytes(data, detectMediaType(data) ?? extensionMediaType(path), options);
+    return bytes(data, fileMediaType(data, path), options);
 });
 /** Materialize an asset and write its bytes through `FileSystem`. */
 export const write = (asset, path) => Effect.gen(function* () {

package/dist/promise.d.ts

@@ -1,40 +1,53 @@
 import { Effect, Layer } from "effect";
-import type { AwaitOptions, Snapshot } from "./generation.js";
+import { AIClient } from "./ai-client.js";
+import type { AwaitOptions, Event, Snapshot } from "./generation.js";
 import { ImageModel, ImageRequest, type ImageOptions, type ImageRequestInput } from "./image.js";
-import { ImageClient } from "./image-client.js";
-import { LLMClient } from "./route/client.js";
+import { Media } from "./media.js";
 import { RequestExecutor } from "./route/executor.js";
 import { LanguageModel, LLMRequest } from "./schema/index.js";
 import type { RequestInput } from "./llm.js";
 import { SpeechModel, SpeechRequest, type SpeechRequestInput } from "./speech.js";
-import { SpeechClient } from "./speech-client.js";
 import { TranscriptionModel, TranscriptionRequest, type TranscriptionOptions, type TranscriptionRequestInput } from "./transcription.js";
-import { TranscriptionClient } from "./transcription-client.js";
 import { VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js";
-import { VideoClient } from "./video-client.js";
 /**
  * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, video, speech,
  * and transcription clients over a request executor; every method runs the corresponding Effect API and rethrows
- * `AIError` unchanged.
+ * `AIError` unchanged. `file` and `write` load `node:fs/promises` on first use, so importing this module does not.
  */
 export interface Options {
-    /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
+    /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or `RequestExecutor.middleware(fn)` here. */
     readonly layer?: Layer.Layer<RequestExecutor.Service>;
 }
 export interface RunOptions {
     readonly signal?: AbortSignal;
 }
-export type Services = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | Layer.Success<typeof VideoClient.layer> | Layer.Success<typeof SpeechClient.layer> | Layer.Success<typeof TranscriptionClient.layer> | RequestExecutor.Service;
-/** Promise view of a `Generation`: its snapshot plus `await`, `refresh`, and `cancel` returning promises. */
+export type Services = AIClient.Services;
+/**
+ * Promise view of a `Generation`. Its fields are a snapshot taken when the handle was created; `refresh()` resolves to a
+ * new handle rather than updating this one.
+ */
 export type GenerationHandle<Response> = Snapshot & {
     /** Serializable JSON; pass it back to `resume` from another process. */
     readonly token: unknown;
     readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>;
+    /** Status observations until the first terminal one, polling like `await`; abort ends iteration without throwing. */
+    readonly events: (options?: AwaitOptions & RunOptions) => AsyncIterable<Event>;
+    /** The result without polling; fails when the generation has not completed. */
+    readonly result: (options?: RunOptions) => Promise<Response>;
     readonly refresh: (options?: RunOptions) => Promise<GenerationHandle<Response>>;
     readonly cancel: (options?: RunOptions) => Promise<void>;
 };
 export declare const make: (options?: Options) => {
     run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    /** Decoded asset bytes, downloading `url` sources through the executor. */
+    bytes: (asset: Media.Asset, options?: RunOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+    base64: (asset: Media.Asset, options?: RunOptions) => Promise<string>;
+    /** Pull a `url` asset into owned bytes before the provider URL expires. */
+    materialize: (asset: Media.Asset, options?: RunOptions) => Promise<Media.Asset>;
+    /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+    file: (path: string, options?: Media.AssetOptions & RunOptions) => Promise<Media.Asset>;
+    /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+    write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
     llm: {
         request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
         generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
@@ -209,7 +222,7 @@ export declare const make: (options?: Options) => {
             readonly namespace?: string | undefined;
         } | {
             readonly type: "media";
-            readonly media: import("./media.js").Asset;
+            readonly media: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -265,11 +278,11 @@ export declare const make: (options?: Options) => {
         } | {
             readonly type: "image-partial";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "image";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -327,7 +340,7 @@ export declare const make: (options?: Options) => {
         } | {
             readonly type: "video";
             readonly index: number;
-            readonly video: import("./media.js").Asset;
+            readonly video: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -382,7 +395,7 @@ export declare const make: (options?: Options) => {
             }[];
         } | {
             readonly type: "finish";
-            readonly audio: import("./media.js").Asset;
+            readonly audio: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -505,6 +518,15 @@ export type Client = ReturnType<typeof make>;
 /** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
 export declare const ai: {
     run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    /** Decoded asset bytes, downloading `url` sources through the executor. */
+    bytes: (asset: Media.Asset, options?: RunOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+    base64: (asset: Media.Asset, options?: RunOptions) => Promise<string>;
+    /** Pull a `url` asset into owned bytes before the provider URL expires. */
+    materialize: (asset: Media.Asset, options?: RunOptions) => Promise<Media.Asset>;
+    /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+    file: (path: string, options?: Media.AssetOptions & RunOptions) => Promise<Media.Asset>;
+    /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+    write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
     llm: {
         request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
         generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
@@ -679,7 +701,7 @@ export declare const ai: {
             readonly namespace?: string | undefined;
         } | {
             readonly type: "media";
-            readonly media: import("./media.js").Asset;
+            readonly media: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;
@@ -735,11 +757,11 @@ export declare const ai: {
         } | {
             readonly type: "image-partial";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "image";
             readonly index: number;
-            readonly image: import("./media.js").Asset;
+            readonly image: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -797,7 +819,7 @@ export declare const ai: {
         } | {
             readonly type: "video";
             readonly index: number;
-            readonly video: import("./media.js").Asset;
+            readonly video: Media.Asset;
         } | {
             readonly type: "finish";
             readonly providerMetadata?: {
@@ -852,7 +874,7 @@ export declare const ai: {
             }[];
         } | {
             readonly type: "finish";
-            readonly audio: import("./media.js").Asset;
+            readonly audio: Media.Asset;
             readonly providerMetadata?: {
                 readonly [x: string]: {
                     readonly [x: string]: unknown;

package/dist/promise.js

@@ -1,16 +1,15 @@
 import { Effect, Layer, ManagedRuntime, Stream } from "effect";
+import { AIClient } from "./ai-client.js";
 import { Image, ImageModel, ImageRequest } from "./image.js";
-import { ImageClient } from "./image-client.js";
 import { LLM } from "./index.js";
-import { LLMClient } from "./route/client.js";
+import { Media } from "./media.js";
+import { tryRequest } from "./media-model.js";
 import { RequestExecutor } from "./route/executor.js";
-import { LanguageModel, LLMRequest } from "./schema/index.js";
+import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js";
 import { Speech, SpeechModel, SpeechRequest } from "./speech.js";
-import { SpeechClient } from "./speech-client.js";
 import { Transcription, TranscriptionModel, TranscriptionRequest, } from "./transcription.js";
-import { TranscriptionClient } from "./transcription-client.js";
+import { fileMediaType } from "./utils/media-type.js";
 import { Video, VideoModel, VideoRequest } from "./video.js";
-import { VideoClient } from "./video-client.js";
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
@@ -23,29 +22,55 @@ const abortEffect = (signal) => signal === undefined
         return Effect.sync(() => signal.removeEventListener("abort", onAbort));
     });
 export const make = (options = {}) => {
-    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer, VideoClient.layer, SpeechClient.layer, TranscriptionClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
-    /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
+    const runtime = ManagedRuntime.make(AIClient.layerWith(options.layer ?? RequestExecutor.fetchLayer));
+    /** Run any package Effect (for example `LLMClient.compact(...)`) inside this runtime. */
     const run = (effect, options) => runtime.runPromise(effect, { signal: options?.signal });
     const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
     const handle = (generation) => ({
         ...generation.snapshot,
         token: generation.token,
         await: (options) => run(generation.await({ poll: options?.poll }), options),
+        events: (options) => iterate(generation.events({ poll: options?.poll }), options),
+        result: (options) => run(generation.result(), options),
         refresh: (options) => run(generation.refresh(), options).then(handle),
         cancel: (options) => run(generation.cancel(), options),
     });
     // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
-    const llmRequest = (input) => (input instanceof LLMRequest ? input : LLM.request(input));
+    const llmRequest = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input));
     const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
     const videoRequest = (input) => input instanceof VideoRequest ? input : Video.request(input);
     const speechRequest = (input) => input instanceof SpeechRequest ? input : Speech.request(input);
     const transcriptionRequest = (input) => input instanceof TranscriptionRequest ? input : Transcription.request(input);
     return {
         run,
+        /** Decoded asset bytes, downloading `url` sources through the executor. */
+        bytes: (asset, options) => run(asset.bytes(), options),
+        base64: (asset, options) => run(asset.base64(), options),
+        /** Pull a `url` asset into owned bytes before the provider URL expires. */
+        materialize: (asset, options) => run(asset.materialize(), options),
+        /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
+        file: async (path, options) => {
+            const { readFile } = await import("node:fs/promises");
+            return run(Effect.tryPromise({
+                try: (signal) => readFile(path, { signal }),
+                catch: (cause) => fileError(`Failed to read media file ${path}`, cause),
+            }).pipe(Effect.map((buffer) => {
+                const data = new Uint8Array(buffer);
+                return Media.bytes(data, fileMediaType(data, path), options);
+            })), options);
+        },
+        /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
+        write: async (asset, path, options) => {
+            const { writeFile } = await import("node:fs/promises");
+            return run(asset.bytes().pipe(Effect.flatMap((data) => Effect.tryPromise({
+                try: (signal) => writeFile(path, data, { signal }),
+                catch: (cause) => fileError(`Failed to write media file ${path}`, cause),
+            }))), options);
+        },
         llm: {
             request: LLM.request,
-            generate: (input, options) => run(LLM.generate(llmRequest(input)), options),
-            stream: (input, options) => iterate(LLM.stream(llmRequest(input)), options),
+            generate: (input, options) => run(Effect.flatMap(llmRequest(input), LLM.generate), options),
+            stream: (input, options) => iterate(Stream.unwrap(Effect.map(llmRequest(input), LLM.stream)), options),
         },
         image: {
             request: Image.request,
@@ -76,6 +101,7 @@ export const make = (options = {}) => {
         dispose: () => runtime.dispose(),
     };
 };
+const fileError = (message, cause) => new AIError({ reason: new InvalidRequestError({ message, cause }) });
 /** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
 export const ai = make();
 export * as AI from "./promise.js";

package/dist/protocols/openai-speech.d.ts

@@ -5,7 +5,11 @@ import { SpeechModel, type SpeechRequestFor } from "../speech.js";
 import { SpeechStream } from "./utils/speech-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export declare const PATH = "/audio/speech";
-export type OpenAISpeechOptions = Record<string, unknown>;
+/** `voice`, `instructions`, `speed`, and `format` are common request fields; other native body fields pass through. */
+export type OpenAISpeechOptions = {
+    /** Defaults to `"sse"` in `stream` mode on models that support it; the merged value selects the response framing. */
+    readonly stream_format?: "sse" | "audio";
+} & Record<string, unknown>;
 export type Request = SpeechRequestFor<OpenAISpeechOptions>;
 interface State extends SpeechStream.Audio {
     readonly done: boolean;

package/dist/protocols/shared.js

@@ -149,7 +149,8 @@ export const mediaReference = (asset, provider, label) => {
     if (provider !== undefined && asset.source.type === "ref" && asset.source.provider === provider)
         return Effect.succeed({ type: "ref", value: asset.source.id });
     const accepted = provider === undefined ? "" : `, and ${provider} references`;
-    return Effect.fail(invalidRequest(`${label} accepts inline bytes, data URLs, http(s) URLs${accepted}`));
+    const got = asset.source.type === "ref" ? `; got ${asset.source.provider}:${asset.source.id}` : "";
+    return Effect.fail(invalidRequest(`${label} accepts inline bytes, data URLs, http(s) URLs${accepted}${got}`));
 };
 /**
  * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in

package/dist/route/auth.d.ts

@@ -4,7 +4,7 @@ import { AIError, type HttpOptions } from "../schema/index.js";
 export declare class MissingCredentialError extends Error {
     readonly source: string;
     readonly _tag = "MissingCredentialError";
-    constructor(source: string);
+    constructor(source: string, message?: string);
 }
 export type CredentialError = MissingCredentialError | Config.ConfigError;
 export type AuthError = CredentialError | AIError;

package/dist/route/auth.js

@@ -1,11 +1,11 @@
-import { Config, Effect, Redacted } from "effect";
+import { Config, Effect, Option, Redacted } from "effect";
 import { Headers } from "effect/unstable/http";
-import { AuthenticationError, InvalidRequestError, AIError } from "../schema/index.js";
+import { AuthenticationError, AIError } from "../schema/index.js";
 export class MissingCredentialError extends Error {
     source;
     _tag = "MissingCredentialError";
-    constructor(source) {
-        super(`Missing auth credential: ${source}`);
+    constructor(source, message = `Missing auth credential: ${source}`) {
+        super(message);
         this.source = source;
     }
 }
@@ -47,7 +47,12 @@ export const value = (secret, source = "value") => credentialFromSecret(secret,
 export const optional = (secret, source = "optional value") => secret === undefined
     ? credential(Effect.fail(new MissingCredentialError(source)))
     : credentialFromSecret(secret, source);
-export const config = (name) => credentialFromSecret(Config.redacted(name), name);
+export const config = (name) => credential(Effect.gen(function* () {
+    const secret = yield* Config.option(Config.redacted(name));
+    if (Option.isSome(secret) && Redacted.value(secret.value) !== "")
+        return secret.value;
+    return yield* Effect.fail(new MissingCredentialError(name, `${name} is not set`));
+}));
 export const effect = (load) => credential(load);
 export const none = auth((input) => Effect.succeed(input.headers));
 export const headers = (input) => auth((inputAuth) => Effect.succeed(Headers.setAll(inputAuth.headers, input)));
@@ -80,14 +85,10 @@ export function scheme(name, source) {
     return render(source);
 }
 const toAIError = (error) => {
-    if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
-        return new AIError({
-            reason: error instanceof MissingCredentialError
-                ? new AuthenticationError({ message: error.message, cause: error })
-                : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
-        });
-    }
-    return error;
+    if (error instanceof AIError)
+        return error;
+    const message = error instanceof MissingCredentialError ? error.message : `Failed to resolve auth config: ${error.message}`;
+    return new AIError({ reason: new AuthenticationError({ message, cause: error }) });
 };
 export const toEffect = (input) => (authInput) => input.apply(authInput).pipe(Effect.mapError(toAIError));
 export * as Auth from "./auth.js";

package/dist/route/client.d.ts

@@ -121,9 +121,11 @@ export declare function canCompact(request: LLMRequest, options?: {
 export declare function canCompact(request: LLMRequest, options: {
     readonly mechanism: "trigger";
 }): request is CheckpointRequest;
-declare const Service_base: Context.ServiceClass<Service, "@opencode/LLMClient", Interface>;
-export declare class Service extends Service_base {
+declare const LLMClientService_base: Context.ServiceClass<LLMClientService, "@opencode/LLMClient", Interface>;
+export declare class LLMClientService extends LLMClientService_base {
 }
+export declare const Service: typeof LLMClientService;
+export type Service = LLMClientService;
 export interface MakeInput<Body, Frame, Event, State> {
     readonly compact?: CompactionOperations;
     /** Route id used in diagnostics and prepared request metadata. */
@@ -423,7 +425,7 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
             readonly [x: string]: unknown;
         };
     } | undefined;
-}, AIError, Service>;
+}, AIError, LLMClientService>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const Route: {
     readonly make: typeof make;
@@ -431,8 +433,8 @@ export declare const Route: {
 export declare const LLMClient: {
     readonly canCompact: typeof canCompact;
     readonly compact: typeof compact;
-    readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly Service: typeof LLMClientService;
+    readonly layer: Layer.Layer<LLMClientService, never, import("./executor-service.js").RequestExecutorService>;
     readonly stream: typeof stream;
     readonly generate: typeof generate;
 };

package/dist/route/client.js

@@ -66,8 +66,9 @@ const unsupportedCompaction = (request, mechanism) => {
         message: `${request.model.provider}/${request.model.route.id} does not support ${mechanism === "trigger" ? "trigger" : "explicit"} compaction`,
     });
 };
-export class Service extends Context.Service()("@opencode/LLMClient") {
+export class LLMClientService extends Context.Service()("@opencode/LLMClient") {
 }
+export const Service = LLMClientService;
 const resolveRequestOptions = (request) => {
     const messages = normalizeToolHistory(request.messages);
     const normalized = messages === request.messages ? request : LLMRequest.update(request, { messages });

package/dist/route/executor-service.d.ts

@@ -6,7 +6,9 @@ export interface Interface {
 }
 export type HttpHandler = (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
 export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, handler: HttpHandler) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
-declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
-export declare class Service extends Service_base {
+declare const RequestExecutorService_base: Context.ServiceClass<RequestExecutorService, "@opencode/AI/RequestExecutor", Interface>;
+export declare class RequestExecutorService extends RequestExecutorService_base {
 }
+export declare const Service: typeof RequestExecutorService;
+export type Service = RequestExecutorService;
 export {};

package/dist/route/executor-service.js

@@ -1,3 +1,4 @@
 import { Context } from "effect";
-export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
+export class RequestExecutorService extends Context.Service()("@opencode/AI/RequestExecutor") {
 }
+export const Service = RequestExecutorService;

package/dist/route/executor.d.ts

@@ -18,5 +18,7 @@ export declare const httpFailure: (input: {
 export declare const responseStream: (response: HttpClientResponse.HttpClientResponse) => Stream.Stream<Uint8Array, AIError>;
 export declare const stream: (executor: Interface, request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Stream.Stream<Uint8Array, AIError>;
 export declare const layer: Layer.Layer<Service, never, HttpClient.HttpClient>;
-export declare const fetchLayer: Layer.Layer<Service, never, never>;
+export declare const fetchLayer: Layer.Layer<import("./executor-service.js").RequestExecutorService, never, never>;
+/** Run `fn` on every request: it sees the raw response before status classification, inside middleware already on `executor`, and outside per-call middleware. */
+export declare const middleware: (fn: HttpMiddleware, executor?: Layer.Layer<Service>) => Layer.Layer<Service>;
 export * as RequestExecutor from "./executor.js";

package/dist/route/executor.js

@@ -180,4 +180,11 @@ export const layer = Layer.effect(Service, Effect.gen(function* () {
     });
 }));
 export const fetchLayer = layer.pipe(Layer.provide(FetchHttpClient.layer));
+/** Run `fn` on every request: it sees the raw response before status classification, inside middleware already on `executor`, and outside per-call middleware. */
+export const middleware = (fn, executor = fetchLayer) => Layer.effect(Service, Effect.gen(function* () {
+    const inner = yield* Service;
+    return Service.of({
+        execute: (request, next) => inner.execute(request, next === undefined ? fn : (input, handler) => fn(input, (forwarded) => next(forwarded, handler))),
+    });
+})).pipe(Layer.provide(executor));
 export * as RequestExecutor from "./executor.js";

package/dist/route/index.d.ts

@@ -1,5 +1,5 @@
 export { Route, LLMClient } from "./client.js";
-export type { Route as RouteShape, RouteLanguageModelInput, RouteRoutedLanguageModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, Service as LLMClientService, StreamOptions, CompactMethod, CompactionOperations, CompactionRequest, CheckpointRequest, EndpointCompactOptions, TriggerCompactOptions, } from "./client.js";
+export type { Route as RouteShape, RouteLanguageModelInput, RouteRoutedLanguageModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, LLMClientService, StreamOptions, CompactMethod, CompactionOperations, CompactionRequest, CheckpointRequest, EndpointCompactOptions, TriggerCompactOptions, } from "./client.js";
 export * from "./executor.js";
 export { Auth } from "./auth.js";
 export { AuthOptions } from "./auth-options.js";

package/dist/speech-client.d.ts

@@ -6,15 +6,17 @@ export interface Interface {
     readonly generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError>;
     readonly stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/SpeechClient", Interface>;
-export declare class Service extends Service_base {
+declare const SpeechClientService_base: Context.ServiceClass<SpeechClientService, "@opencode/SpeechClient", Interface>;
+export declare class SpeechClientService extends SpeechClientService_base {
 }
+export declare const Service: typeof SpeechClientService;
+export type Service = SpeechClientService;
 export declare const generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError, Service>;
 export declare const stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError, Service>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const SpeechClient: {
-    readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly Service: typeof SpeechClientService;
+    readonly layer: Layer.Layer<SpeechClientService, never, import("./route/executor-service.js").RequestExecutorService>;
     readonly generate: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Effect.Effect<SpeechResponse, AIError, Service>;
     readonly stream: <Options extends SpeechOptions>(request: SpeechRequestFor<Options>) => Stream.Stream<SpeechEvent, AIError, Service>;
 };

package/dist/speech-client.js

@@ -1,7 +1,8 @@
 import { Context, Effect, Layer, Stream } from "effect";
 import { RequestExecutor } from "./route/executor.js";
-export class Service extends Context.Service()("@opencode/SpeechClient") {
+export class SpeechClientService extends Context.Service()("@opencode/SpeechClient") {
 }
+export const Service = SpeechClientService;
 export const generate = (request) => Effect.gen(function* () {
     const client = yield* Service;
     return yield* client.generate(request);

package/dist/testing.d.ts

@@ -1743,11 +1743,11 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
     } | undefined;
 }, never, never>;
 /** Provides one shared implementation under the normal client and test-control tags. */
-export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").Service | Test, never, never>;
+export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").LLMClientService | Test, never, never>;
 /** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
 export declare const layer: (options?: LayerOptions) => Layer.Layer<Service, never, never>;
 /** @deprecated testLayer provides LLMClient.Service directly. */
-export declare const clientLayer: Layer.Layer<import("./route/client.js").Service, never, Service>;
+export declare const clientLayer: Layer.Layer<import("./route/client.js").LLMClientService, never, Service>;
 export declare const push: (...responses: readonly Response[]) => Effect.Effect<void, never, Service>;
 export declare const always: (response: Response) => Effect.Effect<void, never, Service>;
 export declare const wait: (count: number) => Effect.Effect<void, never, Service>;

package/dist/transcription-client.d.ts

@@ -9,17 +9,19 @@ export interface Interface {
     readonly start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError>;
     readonly resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/TranscriptionClient", Interface>;
-export declare class Service extends Service_base {
+declare const TranscriptionClientService_base: Context.ServiceClass<TranscriptionClientService, "@opencode/TranscriptionClient", Interface>;
+export declare class TranscriptionClientService extends TranscriptionClientService_base {
 }
+export declare const Service: typeof TranscriptionClientService;
+export type Service = TranscriptionClientService;
 export declare const generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError, Service>;
 export declare const stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError, Service>;
 export declare const start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
 export declare const resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const TranscriptionClient: {
-    readonly Service: typeof Service;
-    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly Service: typeof TranscriptionClientService;
+    readonly layer: Layer.Layer<TranscriptionClientService, never, import("./route/executor-service.js").RequestExecutorService>;
     readonly generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError, Service>;
     readonly stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError, Service>;
     readonly start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;

package/dist/transcription-client.js

@@ -2,8 +2,9 @@ import { Context, Effect, Layer, Stream } from "effect";
 import { RequestExecutor } from "./route/executor.js";
 import { MediaRoute } from "./route/media.js";
 import { responseEvents, } from "./transcription.js";
-export class Service extends Context.Service()("@opencode/TranscriptionClient") {
+export class TranscriptionClientService extends Context.Service()("@opencode/TranscriptionClient") {
 }
+export const Service = TranscriptionClientService;
 export const generate = (request, options) => Effect.gen(function* () {
     const client = yield* Service;
     return yield* client.generate(request, options);

package/dist/transcription.d.ts

@@ -1012,7 +1012,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     readonly confidence?: number | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "text-delta" | "generation-queued" | "generation-progress" | "segment">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "text-delta" | "segment">]: never; }, OrElse extends (value: Exclude<{
             readonly id: string;
             readonly type: "generation-queued";
             readonly position?: number | undefined;
@@ -1245,7 +1245,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     readonly confidence?: number | undefined;
                 }[] | undefined;
             }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "text-delta" | "generation-queued" | "generation-progress" | "segment">]: never; }, OrElse extends (value: Exclude<{
+        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "text-delta" | "segment">]: never; }, OrElse extends (value: Exclude<{
             readonly id: string;
             readonly type: "generation-queued";
             readonly position?: number | undefined;

package/dist/utils/media-type.d.ts

@@ -3,5 +3,6 @@
  * `undefined` so callers can fall back to a provider-declared type or `application/octet-stream`.
  */
 export declare const detectMediaType: (bytes: Uint8Array) => string | undefined;
-export declare const extensionMediaType: (path: string) => string | undefined;
+/** Media type of a file's contents: sniffed magic bytes, then the path's extension. */
+export declare const fileMediaType: (bytes: Uint8Array, path: string) => string | undefined;
 export declare const mediaTypeExtension: (mediaType: string) => string | undefined;

package/dist/utils/media-type.js

@@ -54,7 +54,9 @@ const EXTENSIONS = {
     md: "text/markdown",
     csv: "text/csv",
 };
-export const extensionMediaType = (path) => EXTENSIONS[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
+const extensionMediaType = (path) => EXTENSIONS[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
+/** Media type of a file's contents: sniffed magic bytes, then the path's extension. */
+export const fileMediaType = (bytes, path) => detectMediaType(bytes) ?? extensionMediaType(path);
 const EXTENSION_ALIASES = {
     "audio/mp3": "mp3",
     "audio/m4a": "m4a",