@opencode/ai 2.0.15 → 2.0.16

package/dist/route/media.js

@@ -1,49 +1,221 @@
-import { Effect } 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 { Service as RequestExecutorService } from "./executor-service.js";
+import { RequestExecutor } from "./executor.js";
 import { MediaProtocol } from "./media-protocol.js";
+import { Generation, resultEvents, } from "../generation.js";
 import { ProviderShared } from "../protocols/shared.js";
-import { AIError, HttpOptions, 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
- * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field rejection, URL and query
- * rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol for decoding.
+ * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
+ * rejection, URL and query rendering, auth headers, JSON, multipart, or binary encoding, and handing responses back
+ * to the protocol.
  */
-export const make = (input) => {
+export const inline = (input) => {
+    const transport = makeTransport(input);
+    return {
+        kind: "inline",
+        id: input.id,
+        provider: transport.provider,
+        protocol: input.protocol.id,
+        generate: Effect.fn(`MediaRoute.generate`)(function* (request, execute) {
+            const submitted = yield* transport.submit(request, { unsupported: input.protocol.unsupported, from: input.protocol.body.from }, execute);
+            return yield* input.protocol.response.decode(submitted.response, submitted.context);
+        }),
+    };
+};
+/**
+ * Compose a queued media protocol the same way, adding `start`/`resume` handles whose polls reuse the route's auth,
+ * deployment headers, and (for `start`) the request's `http` overlay. The token is decoded once at the boundary and
+ * closed over by the resulting `Generation.Route`.
+ */
+export const queued = (input) => {
+    const transport = makeTransport(input);
+    const protocol = input.protocol;
+    const decodeToken = Schema.decodeUnknownEffect(protocol.token);
+    // A protocol producing a token its own codec rejects is a programmer defect, not a provider error.
+    const encodeToken = Schema.encodeSync(protocol.token);
+    const generationRoute = (token, http, execute) => {
+        const materialize = (asset) => asset.materialize().pipe(Effect.provideService(RequestExecutorService, { execute }));
+        const poll = (operation) => transport
+            .call("GET", operation.path(token), http, execute)
+            .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth, materialize })));
+        const cancel = protocol.cancel;
+        const route = {
+            status: poll(protocol.status),
+            result: poll(protocol.result),
+            cancel: cancel === undefined
+                ? undefined
+                : transport.call(cancel.method, cancel.path(token), http, execute).pipe(Effect.asVoid),
+        };
+        return route;
+    };
+    const start = Effect.fn("MediaRoute.start")(function* (request, execute) {
+        const submitted = yield* transport.submit(request, { unsupported: protocol.unsupported, prepare: protocol.start.prepare, from: protocol.start.body.from }, execute);
+        const started = yield* protocol.start.decode(submitted.response, submitted.context);
+        const route = generationRoute(started.token, submitted.context.request.http, execute);
+        return new Generation(route, encodeToken(started.token), started.snapshot);
+    });
+    const resume = Effect.fn("MediaRoute.resume")(function* (model, raw, execute) {
+        const token = yield* decodeToken(raw).pipe(Effect.mapError((cause) => new AIError({
+            reason: new InvalidRequestError({
+                message: `${input.id} cannot resume a generation from this token`,
+                cause,
+            }),
+        })));
+        const route = generationRoute(token, transport.http(model), execute);
+        return new Generation(route, encodeToken(token), yield* route.status);
+    });
+    return { kind: "queued", 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 {
+        kind: "stream",
+        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)),
+    };
+};
+export const dispatch = (input) => {
+    const notQueued = (route, operation) => ProviderShared.unsupportedOperation({
+        operation: `${input.modality}.${operation}`,
+        provider: route.provider,
+        route: route.id,
+        message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
+    });
+    const start = (route, request) => {
+        if (route.kind !== "queued")
+            return Effect.fail(notQueued(route, "start"));
+        return route.start(request, input.execute);
+    };
+    return {
+        start,
+        resume: (route, model, token) => {
+            if (route.kind !== "queued")
+                return Effect.fail(notQueued(route, "resume"));
+            return route.resume(model, token, input.execute);
+        },
+        generate: (route, request, options) => {
+            if (route.kind !== "queued")
+                return route.generate(request, input.execute);
+            return start(route, request).pipe(Effect.flatMap((generation) => generation.await(options)));
+        },
+        stream: (route, request, options) => {
+            if (route.kind === "stream")
+                return route.stream(request, input.execute);
+            if (route.kind === "queued")
+                return Stream.unwrap(start(route, request).pipe(Effect.map((generation) => resultEvents(generation, input.responseEvents, options))));
+            return Stream.fromIterableEffect(Effect.map(route.generate(request, input.execute), input.responseEvents));
+        },
+    };
+};
+// ---------------------------------------------------------------------------
+// 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 baseURL = (path) => new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`);
+    /** `auth` is only what `Auth` added, never deployment headers. */
+    const send = Effect.fn("MediaRoute.send")(function* (call, execute) {
+        const encoded = encode(call.body, call.headers);
+        const url = call.url.toString();
+        const headers = yield* authorize({
+            request: call.request,
+            method: call.method,
+            url,
+            body: encoded.text,
+            headers: encoded.headers,
+        });
+        const response = yield* execute(encoded.apply(HttpClientRequest.make(call.method)(url).pipe(HttpClientRequest.setHeaders(headers))));
+        return { response, auth: Object.fromEntries(Object.entries(headers).filter(([key]) => !(key in call.headers))) };
+    });
     return {
-        id: input.id,
         provider,
-        protocol: input.protocol.id,
-        generate: Effect.fn(`MediaRoute.generate`)(function* (request, execute) {
-            yield* rejectUnsupported(input.id, provider, request, input.protocol.unsupported);
+        /** Route and model overlays; `start` additionally merges the request's own `http`. */
+        http: (model) => mergeHttpOptions(routeHttp, model.http),
+        /** POST the protocol body to the route endpoint. */
+        submit: Effect.fn("MediaRoute.submit")(function* (request, protocol, execute) {
+            yield* rejectUnsupported(input.id, provider, request, protocol.unsupported);
             const http = mergeHttpOptions(routeHttp, request.model.http, request.http);
+            const headers = Headers.fromInput(http?.headers);
+            const prepared = protocol.prepare === undefined
+                ? request
+                : yield* protocol.prepare(request, (path, body) => send({ method: "POST", url: baseURL(path), headers, request, body }, 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 = { ...sanitizeSurrogates({ ...request, http }), model: request.model };
-            const body = yield* input.protocol.body.from(resolved);
-            const url = Endpoint.render(input.endpoint, { request: resolved, body });
-            for (const [key, value] of Object.entries(http?.query ?? {}))
-                url.searchParams.set(key, value);
-            const encoded = body.type === "json" ? ProviderShared.encodeJson(body.value) : "[multipart/form-data]";
-            const baseHeaders = Headers.fromInput(http?.headers);
-            const headers = yield* authorize({
-                request: resolved,
-                method: "POST",
-                url: url.toString(),
-                body: encoded,
-                // The HTTP client sets the multipart boundary; a caller-supplied content-type would corrupt it.
-                headers: body.type === "multipart" ? Headers.remove(baseHeaders, "content-type") : baseHeaders,
-            });
-            const transport = HttpClientRequest.post(url.toString()).pipe(HttpClientRequest.setHeaders(headers), body.type === "json"
-                ? HttpClientRequest.bodyText(encoded, "application/json")
-                : HttpClientRequest.bodyFormData(body.value));
-            const response = yield* execute(transport);
-            return yield* input.protocol.response.decode(response, { request: resolved, body });
+            const resolved = { ...sanitizeSurrogates({ ...prepared, http }), model: request.model };
+            const body = yield* protocol.from(resolved);
+            const url = withQuery(withQuery(Endpoint.render(input.endpoint, { request: resolved, body }), body.type === "multipart" ? undefined : body.query), http?.query);
+            const sent = yield* send({ method: "POST", url, headers, request: resolved, body }, execute);
+            return { response: sent.response, context: { request: resolved, body } };
         }),
+        /** Bodiless follow-up call (status, result, cancel) with the same auth and headers as `submit`. */
+        call: (method, path, http, execute) => {
+            // 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) : baseURL(path), http?.query);
+            for (const [key, value] of Object.entries(input.endpoint.query ?? {}))
+                url.searchParams.set(key, value);
+            return send({ method, url, headers: Headers.fromInput(http?.headers), request: { http } }, execute);
+        },
+    };
+};
+const withQuery = (url, query) => {
+    for (const [key, value] of Object.entries(query ?? {})) {
+        url.searchParams.delete(key);
+        for (const item of typeof value === "string" ? [value] : value)
+            url.searchParams.append(key, item);
+    }
+    return url;
+};
+const encode = (body, headers) => {
+    if (body === undefined)
+        return { text: "", headers, apply: (request) => request };
+    if (body.type === "json") {
+        const text = ProviderShared.encodeJson(body.value);
+        return { text, headers, apply: HttpClientRequest.bodyText(text, "application/json") };
+    }
+    if (body.type === "binary")
+        return {
+            text: `[${body.contentType}]`,
+            headers,
+            apply: HttpClientRequest.bodyUint8Array(body.value, body.contentType),
+        };
+    return {
+        text: "[multipart/form-data]",
+        // The HTTP client sets the multipart boundary; a caller-supplied content-type would corrupt it.
+        headers: Headers.remove(headers, "content-type"),
+        apply: HttpClientRequest.bodyFormData(body.value),
     };
 };
 /** Common fields are never silently dropped: a present field the protocol declared unsupported fails typed. */

package/dist/schema/events.d.ts

@@ -365,7 +365,6 @@ export declare const MediaEvent: Schema.Struct<{
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -578,7 +577,6 @@ declare const llmEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.refi
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -820,7 +818,6 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -1064,7 +1061,6 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
                     readonly url: Schema.String;
                     readonly mediaType: Schema.optional<Schema.String>;
                     readonly expiresAt: Schema.optional<Schema.Number>;
-                    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
                 }>, Schema.Struct<{
                     readonly type: Schema.Literal<"ref">;
                     readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -4805,7 +4801,6 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly url: Schema.String;
                 readonly mediaType: Schema.optional<Schema.String>;
                 readonly expiresAt: Schema.optional<Schema.Number>;
-                readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"ref">;
                 readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -5049,7 +5044,6 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                         readonly url: Schema.String;
                         readonly mediaType: Schema.optional<Schema.String>;
                         readonly expiresAt: Schema.optional<Schema.Number>;
-                        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
                     }>, Schema.Struct<{
                         readonly type: Schema.Literal<"ref">;
                         readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;

package/dist/schema/messages.d.ts

@@ -44,7 +44,6 @@ export declare const MediaPart: Schema.Struct<{
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -305,7 +304,6 @@ export declare const ContentPart: Schema.toTaggedUnion<"type", readonly [Schema.
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -450,7 +448,6 @@ declare const Message_base: Schema.Class<Message, Schema.Struct<{
                 readonly url: Schema.String;
                 readonly mediaType: Schema.optional<Schema.String>;
                 readonly expiresAt: Schema.optional<Schema.Number>;
-                readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"ref">;
                 readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;

package/dist/schema/options.d.ts

@@ -70,12 +70,13 @@ export declare namespace LanguageModelDefaults {
 export declare const ReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {});
 export declare const ReasoningEffort: Schema.declare<ReasoningEffort, ReasoningEffort>;
-export declare const LanguageModelToolSchemaCompatibility: Schema.Literals<readonly ["gemini", "moonshot"]>;
-export type LanguageModelToolSchemaCompatibility = Schema.Schema.Type<typeof LanguageModelToolSchemaCompatibility>;
+/** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
+export declare const LanguageModelSanitizerCompatibility: Schema.Literals<readonly ["gemini", "moonshot", "none"]>;
+export type LanguageModelSanitizerCompatibility = Schema.Schema.Type<typeof LanguageModelSanitizerCompatibility>;
 export declare const LanguageModelMaxTokensFieldCompatibility: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
 export type LanguageModelMaxTokensFieldCompatibility = Schema.Schema.Type<typeof LanguageModelMaxTokensFieldCompatibility>;
 declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompatibility, Schema.Struct<{
-    readonly toolSchema: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot"]>>;
+    readonly sanitizer: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot", "none"]>>;
     readonly reasoningField: Schema.optional<Schema.String>;
     /** Require every assistant message to include its reasoning field, even when empty. */
     readonly requireReasoning: Schema.optional<Schema.Boolean>;

package/dist/schema/options.js

@@ -99,10 +99,11 @@ export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaul
 })(LanguageModelDefaults || (LanguageModelDefaults = {}));
 export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export const ReasoningEffort = Schema.declare((value) => typeof value === "string", { title: "ReasoningEffort" });
-export const LanguageModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"]);
+/** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
+export const LanguageModelSanitizerCompatibility = Schema.Literals(["gemini", "moonshot", "none"]);
 export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"]);
 export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelCompatibility")({
-    toolSchema: Schema.optional(LanguageModelToolSchemaCompatibility),
+    sanitizer: Schema.optional(LanguageModelSanitizerCompatibility),
     reasoningField: Schema.optional(Schema.String),
     /** Require every assistant message to include its reasoning field, even when empty. */
     requireReasoning: Schema.optional(Schema.Boolean),

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,
+};