@opencode/ai 0.0.0-dev-20039 → 0.0.0-dev-20041

package/dist/providers/google.js

@@ -2,6 +2,7 @@ import { Auth } from "../route/auth.js";
 import { HttpOptions, ProviderID, mergeHttpOptions } from "../schema/index.js";
 import { Gemini } from "../protocols/gemini.js";
 import { GoogleImages } from "../protocols/google-images.js";
+import { GoogleSpeech } from "../protocols/google-speech.js";
 import { GoogleVideo } from "../protocols/google-video.js";
 export const id = ProviderID.make("google");
 export const routes = [Gemini.route];
@@ -30,6 +31,7 @@ export const configure = (input = {}) => {
         model: (modelID) => route.model({ id: modelID }),
         image: (modelID) => GoogleImages.model(media(modelID)),
         video: (modelID) => GoogleVideo.model(media(modelID)),
+        speech: (modelID) => GoogleSpeech.model(media(modelID)),
         configure,
     };
 };
@@ -43,3 +45,4 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
 }).model(modelID);
 export const image = provider.image;
 export const video = provider.video;
+export const speech = provider.speech;

package/dist/providers/index.d.ts

@@ -5,11 +5,14 @@ export * as AmazonBedrock from "./amazon-bedrock.js";
 export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js";
 export * as Azure from "./azure.js";
 export * as Baseten from "./baseten.js";
+export * as Cartesia from "./cartesia.js";
 export * as Cerebras from "./cerebras.js";
 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js";
 export * as DeepInfra from "./deepinfra.js";
+export * as Deepgram from "./deepgram.js";
 export * as DeepSeek from "./deepseek.js";
+export * as ElevenLabs from "./elevenlabs.js";
 export * as Fal from "./fal.js";
 export * as Fireworks from "./fireworks.js";
 export * as Google from "./google.js";

package/dist/providers/index.js

@@ -5,11 +5,14 @@ export * as AmazonBedrock from "./amazon-bedrock.js";
 export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js";
 export * as Azure from "./azure.js";
 export * as Baseten from "./baseten.js";
+export * as Cartesia from "./cartesia.js";
 export * as Cerebras from "./cerebras.js";
 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js";
 export * as DeepInfra from "./deepinfra.js";
+export * as Deepgram from "./deepgram.js";
 export * as DeepSeek from "./deepseek.js";
+export * as ElevenLabs from "./elevenlabs.js";
 export * as Fal from "./fal.js";
 export * as Fireworks from "./fireworks.js";
 export * as Google from "./google.js";

package/dist/providers/openai.d.ts

@@ -7,6 +7,7 @@ import { type OpenAIProviderOptionsInput } from "./openai-options.js";
 import { type OpenAIImageString } from "../protocols/openai-images.js";
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options.js";
 export type { OpenAIImageOptions } from "../protocols/openai-images.js";
+export type { OpenAISpeechOptions } from "../protocols/openai-speech.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export declare const routes: (Route<{
     readonly model: string;
@@ -372,6 +373,7 @@ export declare const configure: (input?: Config) => {
     }>;
     chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
@@ -386,6 +388,7 @@ export declare const provider: {
     }>;
     chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, {
@@ -398,6 +401,7 @@ export declare const provider: {
         }>;
         chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
+        speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;
         configure: /*elided*/ any;
     };
 };
@@ -409,3 +413,4 @@ export declare const responses: (id: string | ModelID) => import("../schema/opti
 }>;
 export declare const chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
+export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;

package/dist/providers/openai.js

@@ -4,6 +4,7 @@ import * as OpenAIChat from "../protocols/openai-chat.js";
 import * as OpenAIResponses from "../protocols/openai-responses.js";
 import { withOpenAIOptions } from "./openai-options.js";
 import { OpenAIImages } from "../protocols/openai-images.js";
+import { OpenAISpeech } from "../protocols/openai-speech.js";
 export const id = ProviderID.make("openai");
 export const routes = [OpenAIResponses.route, OpenAIChat.route];
 export const imageGeneration = (options = {}) => ToolDefinition.make({
@@ -44,19 +45,22 @@ export const configure = (input = {}) => {
         id,
         compatibility: { supportsPromptCacheKey: true },
     });
-    const image = (modelID) => OpenAIImages.model({
+    const media = (modelID) => ({
         id: modelID,
         auth: auth(input),
         baseURL: input.baseURL,
         headers: input.headers,
         http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http), input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams })),
     });
+    const image = (modelID) => OpenAIImages.model(media(modelID));
+    const speech = (modelID) => OpenAISpeech.model(media(modelID));
     return {
         id,
         model: responses,
         responses,
         chat,
         image,
+        speech,
         configure,
     };
 };
@@ -83,3 +87,4 @@ export const chatModel = (modelID, settings) => configure(config(settings)).chat
 export const responses = provider.responses;
 export const chat = provider.chat;
 export const image = provider.image;
+export const speech = provider.speech;

package/dist/route/framing.d.ts

@@ -1,4 +1,4 @@
-import type { Stream } from "effect";
+import { Stream } from "effect";
 import type { AIError } from "../schema/index.js";
 /**
  * Decode a streaming HTTP response body into provider-protocol frames.
@@ -10,6 +10,8 @@ import type { AIError } from "../schema/index.js";
  *   `[DONE]`; protocols that use it as a terminal select `sseWithDone`.
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
+ * - Media streams — newline-delimited JSON (`lines`) or the whole body as one
+ *   frame (`document`); chunked binary bodies need no framing.
  *
  * The frame type is opaque to this layer; the protocol's event schema decodes
  * each frame before its state machine handles it.
@@ -26,4 +28,6 @@ export declare const sse: Definition<string>;
 export declare const sseWithDone: Definition<string>;
 /** SSE framing restricted to protocol-recognized event names. */
 export declare const sseEvents: (events: ReadonlySet<string>) => Definition<string>;
+export declare const lines: Definition<string>;
+export declare const document: Definition<string>;
 export * as Framing from "./framing.js";

package/dist/route/framing.js

@@ -1,3 +1,4 @@
+import { Stream } from "effect";
 import * as ProviderShared from "../protocols/shared.js";
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse = { id: "sse", frame: ProviderShared.sseFraming };
@@ -11,4 +12,12 @@ export const sseEvents = (events) => ({
     id: "sse",
     frame: (bytes) => ProviderShared.sseFraming(bytes, events),
 });
+export const lines = {
+    id: "lines",
+    frame: (bytes) => bytes.pipe(Stream.decodeText(), Stream.splitLines, Stream.filter((line) => line.trim().length > 0)),
+};
+export const document = {
+    id: "document",
+    frame: (bytes) => Stream.fromEffect(Stream.mkString(bytes.pipe(Stream.decodeText()))),
+};
 export * as Framing from "./framing.js";

package/dist/route/media-protocol.d.ts

@@ -1,17 +1,19 @@
-import { Duration, Effect, Schema } from "effect";
+import { Duration, Effect, Schema, type Stream } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
 import type { Snapshot, Status } from "../generation.js";
 import { Media } from "../media.js";
 import type { AuthInput } from "./auth.js";
 import { AIError, HttpContext } from "../schema/index.js";
+/** JSON `query` is appended to the endpoint URL before the route and caller `http.query` overlays. */
 export type Body = {
     readonly type: "json";
     readonly value: Record<string, unknown>;
+    readonly query?: Record<string, string>;
 } | {
     readonly type: "multipart";
     readonly value: FormData;
 };
-export declare const json: (value: Record<string, unknown>) => Body;
+export declare const json: (value: Record<string, unknown>, query?: Record<string, string>) => Body;
 export declare const multipart: (value: FormData) => Body;
 export interface DecodeContext<Request> {
     readonly request: Request;
@@ -80,6 +82,33 @@ export interface Queued<Request, Response, Token> {
     };
 }
 export declare const queued: <Request, Response, Token>(input: Omit<Queued<Request, Response, Token>, "kind">) => Queued<Request, Response, Token>;
+export type Mode = "generate" | "stream";
+export type Addressed<Request> = Request & {
+    readonly mode: Mode;
+};
+export interface ResponseContext<Request> extends DecodeContext<Addressed<Request>> {
+    readonly http: HttpContext;
+}
+/**
+ * One request whose body is parsed incrementally, like LLM protocols: `frames` → `step`* → `finish`. `generate` and
+ * `stream` share this state machine; `request.mode` lets a protocol pick a different body, path, or framing.
+ */
+export interface Streamed<Request, Event, Frame, State> {
+    readonly kind: "stream";
+    readonly id: string;
+    readonly name: string;
+    /** Common request fields this protocol cannot lower; the route rejects them before `body.from` runs. */
+    readonly unsupported?: ReadonlyArray<keyof Request & string>;
+    readonly body: {
+        readonly from: (request: Addressed<Request>) => Effect.Effect<Body, AIError>;
+    };
+    readonly frames: (bytes: Stream.Stream<Uint8Array, AIError>, context: DecodeContext<Addressed<Request>>) => Stream.Stream<Frame, AIError>;
+    readonly initial: () => State;
+    readonly step: (state: State, frame: Frame) => Effect.Effect<readonly [State, ReadonlyArray<Event>], AIError>;
+    /** Emit exactly one terminal event, or fail when the provider stopped before completing. */
+    readonly finish: (state: State, context: ResponseContext<Request>) => Effect.Effect<ReadonlyArray<Event>, AIError>;
+}
+export declare const stream: <Request, Event, Frame, State>(input: Omit<Streamed<Request, Event, Frame, State>, "kind">) => Streamed<Request, Event, Frame, State>;
 /**
  * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
  * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
@@ -106,6 +135,10 @@ export declare const decodeJson: <A>(route: string, name: string, schema: Schema
 export declare const decodeStarted: <A, Token>(route: string, name: string, schema: Schema.Codec<A, unknown>, started: (value: A) => Started<Token>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<Started<Token>, AIError, never>;
 /** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
 export declare const status: <Table extends Record<string, Status>>(table: Table, raw: string, output: Output) => Effect.Effect<Status, AIError>;
+export declare const frameError: (route: string, message: string, body?: string, cause?: unknown) => AIError;
+export declare const incomplete: (route: string) => AIError;
+/** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
+export declare const decodeFrame: <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => (frame: string) => Effect.Effect<A, AIError, never>;
 /** A `url` asset whose provider-declared retention window starts now. */
 export declare const expiringUrl: (url: string, retention: Duration.Duration, options?: Parameters<typeof Media.url>[1]) => Effect.Effect<Media.Asset, never, never>;
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media-protocol.js

@@ -2,7 +2,11 @@ import { Clock, Duration, Effect, Schema } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
 import { Media } from "../media.js";
 import { AIError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderInternalError, } from "../schema/index.js";
-export const json = (value) => ({ type: "json", value });
+export const json = (value, query) => ({
+    type: "json",
+    value,
+    query,
+});
 export const multipart = (value) => ({ type: "multipart", value });
 export const inline = (input) => ({
     kind: "inline",
@@ -12,6 +16,10 @@ export const queued = (input) => ({
     kind: "queued",
     ...input,
 });
+export const stream = (input) => ({
+    kind: "stream",
+    ...input,
+});
 // ---------------------------------------------------------------------------
 // Response helpers
 // ---------------------------------------------------------------------------
@@ -64,6 +72,19 @@ export const status = (table, raw, output) => {
         return Effect.fail(output.invalid(`Unknown generation status "${raw}"`));
     return Effect.succeed(normalized);
 };
+export const frameError = (route, message, body, cause) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body, cause }) });
+export const incomplete = (route) => new AIError({
+    reason: new InvalidProviderOutputError({
+        route,
+        message: "The provider response ended unexpectedly.",
+        classification: "incomplete-stream",
+    }),
+});
+/** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
+export const decodeFrame = (route, name, schema) => {
+    const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema));
+    return (frame) => decode(frame).pipe(Effect.mapError((cause) => frameError(route, `${name} sent an invalid stream event`, frame, cause)));
+};
 /** A `url` asset whose provider-declared retention window starts now. */
 export const expiringUrl = (url, retention, options) => Clock.currentTimeMillis.pipe(Effect.map((now) => Media.url(url, { ...options, expiresAt: now + Duration.toMillis(retention) })));
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media.d.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Stream } from "effect";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
 import type { Interface } from "./executor-service.js";
@@ -39,6 +39,14 @@ export interface QueuedRoute<Request extends MediaRequest, Response> {
     /** Rebuild a handle from a persisted `Generation.token`; fails typed when the token is not this route's. */
     readonly resume: (model: MediaRequest["model"], token: unknown, execute: Execute) => Effect.Effect<Generation<Response>, AIError>;
 }
+/** One request whose response parses into events; `generate` runs the same stream and collects it. */
+export interface StreamRoute<Request extends MediaRequest, Event, Response> {
+    readonly id: string;
+    readonly provider: ProviderID;
+    readonly protocol: string;
+    readonly stream: (request: Request, execute: Execute) => Stream.Stream<Event, AIError>;
+    readonly generate: (request: Request, execute: Execute) => Effect.Effect<Response, AIError>;
+}
 export interface Composition<Request extends MediaRequest> {
     readonly id: string;
     readonly provider: string | ProviderID;
@@ -53,6 +61,10 @@ export interface InlineInput<Request extends MediaRequest, Response> extends Com
 export interface QueuedInput<Request extends MediaRequest, Response, Token> extends Composition<Request> {
     readonly protocol: MediaProtocol.Queued<Request, Response, Token>;
 }
+export interface StreamInput<Request extends MediaRequest, Event, Response, Frame, State> extends Composition<MediaProtocol.Addressed<Request>> {
+    readonly protocol: MediaProtocol.Streamed<Request, Event, Frame, State>;
+    readonly collect: (events: ReadonlyArray<Event>) => Effect.Effect<Response, AIError>;
+}
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
  * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
@@ -66,4 +78,6 @@ export declare const inline: <Request extends MediaRequest, Response>(input: Inl
  * closed over by the resulting `Generation.Route`.
  */
 export declare const queued: <Request extends MediaRequest, Response, Token>(input: QueuedInput<Request, Response, Token>) => QueuedRoute<Request, Response>;
+/** Compose a streaming media protocol; `generate` runs the same stream in `generate` mode and folds it with `collect`. */
+export declare const stream: <Request extends MediaRequest, Event, Response, Frame, State>(input: StreamInput<Request, Event, Response, Frame, State>) => StreamRoute<Request, Event, Response>;
 export * as MediaRoute from "./media.js";

package/dist/route/media.js

@@ -1,11 +1,12 @@
-import { Effect, Schema } from "effect";
+import { Effect, Schema, Stream } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
+import { RequestExecutor } from "./executor.js";
 import { MediaProtocol } from "./media-protocol.js";
 import { Generation } from "../generation.js";
 import { ProviderShared } from "../protocols/shared.js";
-import { AIError, HttpOptions, InvalidRequestError, ProviderID, mergeHttpOptions } from "../schema/index.js";
+import { AIError, AIErrorReason, HttpOptions, InvalidRequestError, ProviderID, mergeHttpOptions, } from "../schema/index.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
@@ -68,15 +69,48 @@ export const queued = (input) => {
     });
     return { id: input.id, provider: transport.provider, protocol: protocol.id, start, resume };
 };
+/** Compose a streaming media protocol; `generate` runs the same stream in `generate` mode and folds it with `collect`. */
+export const stream = (input) => {
+    const transport = makeTransport(input);
+    const protocol = input.protocol;
+    const events = (request, execute, mode) => Stream.unwrap(Effect.gen(function* () {
+        const submitted = yield* transport.submit({ ...request, mode }, { unsupported: protocol.unsupported, from: protocol.body.from }, execute);
+        const http = RequestExecutor.responseHttp(submitted.response);
+        return Stream.suspend(() => {
+            // Parser state is local to one response, exactly like `Route.make`'s LLM stream loop.
+            let state = protocol.initial();
+            return protocol.frames(RequestExecutor.responseStream(submitted.response), submitted.context).pipe(Stream.mapEffect((frame) => protocol.step(state, frame).pipe(Effect.map(([next, output]) => {
+                state = next;
+                return output;
+            }))), Stream.flattenIterable, Stream.concat(Stream.suspend(() => Stream.fromIterableEffect(protocol.finish(state, { ...submitted.context, http })))), Stream.mapError((error) => error.reason.http !== undefined
+                ? error
+                : new AIError({
+                    reason: AIErrorReason.make({
+                        ...error.reason,
+                        message: error.reason.message,
+                        cause: error.reason.cause,
+                        http,
+                    }),
+                })));
+        });
+    }));
+    return {
+        id: input.id,
+        provider: transport.provider,
+        protocol: protocol.id,
+        stream: (request, execute) => events(request, execute, "stream"),
+        generate: (request, execute) => events(request, execute, "generate").pipe(Stream.runCollect, Effect.flatMap(input.collect)),
+    };
+};
 // ---------------------------------------------------------------------------
-// Transport plumbing shared by both kinds
+// Transport plumbing shared by every kind
 // ---------------------------------------------------------------------------
 const makeTransport = (input) => {
     const provider = ProviderID.make(input.provider);
     const routeHttp = input.headers === undefined ? undefined : new HttpOptions({ headers: input.headers });
     const authorize = Auth.toEffect(input.auth);
-    const withQuery = (url, http) => {
-        for (const [key, value] of Object.entries(http?.query ?? {}))
+    const withQuery = (url, query) => {
+        for (const [key, value] of Object.entries(query ?? {}))
             url.searchParams.set(key, value);
         return url;
     };
@@ -91,7 +125,7 @@ const makeTransport = (input) => {
             // Sanitize after merging so model-level overlays are covered; the model value is restored, not sanitized.
             const resolved = { ...sanitizeSurrogates({ ...request, http }), model: request.model };
             const body = yield* protocol.from(resolved);
-            const url = withQuery(Endpoint.render(input.endpoint, { request: resolved, body }), http);
+            const url = withQuery(withQuery(Endpoint.render(input.endpoint, { request: resolved, body }), body.type === "json" ? body.query : undefined), http?.query);
             const encoded = body.type === "json" ? ProviderShared.encodeJson(body.value) : "[multipart/form-data]";
             const baseHeaders = Headers.fromInput(http?.headers);
             const headers = yield* authorize({
@@ -116,7 +150,7 @@ const makeTransport = (input) => {
             // Provider-issued absolute URLs (fal `status_url`) are used as-is; everything else resolves against the base.
             const url = withQuery(/^https?:\/\//.test(path)
                 ? new URL(path)
-                : new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`), http);
+                : new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`), http?.query);
             for (const [key, value] of Object.entries(input.endpoint.query ?? {}))
                 url.searchParams.set(key, value);
             const base = Headers.fromInput(http?.headers);

package/dist/speech-client.d.ts

@@ -0,0 +1,21 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+import type { AIError } from "./schema/index.js";
+import type { SpeechEvent, SpeechOptions, SpeechRequestFor, SpeechResponse } from "./speech.js";
+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 {
+}
+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 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>;
+};
+export {};

package/dist/speech-client.js

@@ -0,0 +1,25 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+export class Service extends Context.Service()("@opencode/SpeechClient") {
+}
+export const generate = (request) => Effect.gen(function* () {
+    const client = yield* Service;
+    return yield* client.generate(request);
+});
+export const stream = (request) => Stream.unwrap(Effect.gen(function* () {
+    const client = yield* Service;
+    return client.stream(request);
+}));
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    return Service.of({
+        generate: (request) => request.model.route.generate(request, executor.execute),
+        stream: (request) => request.model.route.stream(request, executor.execute),
+    });
+}));
+export const SpeechClient = {
+    Service,
+    layer,
+    generate,
+    stream,
+};