@opencode/ai 0.0.0-reserved → 2.0.0

package/dist/protocols/google-images.d.ts

@@ -0,0 +1,30 @@
+import { ImageModel } from "../image.js";
+import { type Definition as AuthDefinition } from "../route/auth.js";
+import { type HttpOptions } from "../schema/index.js";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+export type GoogleImageString<Known extends string> = Known | (string & {});
+export type GoogleImageOptions = {
+    readonly aspectRatio?: GoogleImageString<"1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "4:5" | "5:4" | "9:16" | "16:9" | "21:9">;
+    readonly imageSize?: GoogleImageString<"1K" | "2K" | "4K">;
+    readonly seed?: number;
+    readonly thinkingLevel?: GoogleImageString<"MINIMAL" | "LOW" | "MEDIUM" | "HIGH">;
+    readonly includeThoughts?: boolean;
+} & Record<string, unknown>;
+export type GoogleImageBody = Record<string, unknown> & {
+    readonly contents: ReadonlyArray<{
+        readonly role: "user";
+        readonly parts: ReadonlyArray<Record<string, unknown>>;
+    }>;
+    readonly generationConfig: Record<string, unknown>;
+};
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (input: ModelInput) => ImageModel<GoogleImageOptions>;
+export declare const GoogleImages: {
+    readonly model: (input: ModelInput) => ImageModel<GoogleImageOptions>;
+};

package/dist/protocols/google-images.js

@@ -0,0 +1,181 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse, } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { AIError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared } from "./shared.js";
+import { ImageInputs } from "./utils/image-input.js";
+const ADAPTER = "google-images";
+export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const GoogleUsage = Schema.StructWithRest(Schema.Struct({
+    cachedContentTokenCount: Schema.optional(Schema.Number),
+    thoughtsTokenCount: Schema.optional(Schema.Number),
+    promptTokenCount: Schema.optional(Schema.Number),
+    candidatesTokenCount: Schema.optional(Schema.Number),
+    totalTokenCount: Schema.optional(Schema.Number),
+    promptTokensDetails: Schema.optional(Schema.Unknown),
+    candidatesTokensDetails: Schema.optional(Schema.Unknown),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+const GoogleImageResponse = Schema.Struct({
+    candidates: Schema.optional(Schema.Array(Schema.Struct({
+        index: Schema.optional(Schema.Number),
+        content: Schema.optional(Schema.Struct({
+            parts: Schema.Array(Schema.Struct({
+                text: Schema.optional(Schema.String),
+                thought: Schema.optional(Schema.Boolean),
+                thoughtSignature: Schema.optional(Schema.String),
+                inlineData: Schema.optional(Schema.Struct({
+                    mimeType: Schema.String,
+                    data: Schema.String,
+                })),
+            })),
+        })),
+        finishReason: Schema.optional(Schema.String),
+        finishMessage: Schema.optional(Schema.String),
+        safetyRatings: Schema.optional(Schema.Unknown),
+        citationMetadata: Schema.optional(Schema.Unknown),
+        groundingMetadata: Schema.optional(Schema.Unknown),
+    }))),
+    usageMetadata: Schema.optional(GoogleUsage),
+    modelVersion: Schema.optional(Schema.String),
+    responseId: Schema.optional(Schema.String),
+    promptFeedback: Schema.optional(Schema.Unknown),
+});
+const nativeOptions = (options) => {
+    const { aspectRatio, imageSize, seed, thinkingLevel, includeThoughts, ...native } = options ?? {};
+    const image = {
+        aspectRatio,
+        imageSize,
+    };
+    const thinkingConfig = {
+        thinkingLevel,
+        includeThoughts,
+    };
+    return (mergeJsonRecords({
+        responseModalities: ["IMAGE"],
+        imageConfig: Object.values(image).some((value) => value !== undefined) ? image : undefined,
+        seed,
+        thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
+    }, native) ?? { responseModalities: ["IMAGE"] });
+};
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("GoogleImages.generate")(function* (request, execute) {
+            const imageParts = yield* Effect.forEach(request.images ?? [], googleImagePart);
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const requestBody = mergeJsonRecords({
+                contents: [{ role: "user", parts: [{ text: request.prompt }, ...imageParts] }],
+                generationConfig: nativeOptions(request.options),
+            }, http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}/models/${request.model.id}:generateContent`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const output = yield* ProviderShared.imageResponse(ADAPTER, "Google Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GoogleImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("Google Images returned an invalid response", cause)));
+            const candidates = decoded.candidates ?? [];
+            const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
+                index: candidate.index ?? candidateIndex,
+                finishReason: candidate.finishReason,
+                finishMessage: candidate.finishMessage,
+                safetyRatings: candidate.safetyRatings,
+                citationMetadata: candidate.citationMetadata,
+                groundingMetadata: candidate.groundingMetadata,
+                parts: (candidate.content?.parts ?? []).map((part) => part.inlineData === undefined
+                    ? {
+                        type: "text",
+                        text: part.text,
+                        thought: part.thought,
+                        thoughtSignature: part.thoughtSignature,
+                    }
+                    : {
+                        type: "inlineData",
+                        mediaType: part.inlineData.mimeType,
+                        thought: part.thought,
+                        thoughtSignature: part.thoughtSignature,
+                    }),
+            }));
+            const encoded = candidates.flatMap((candidate, candidateIndex) => (candidate.content?.parts ?? []).flatMap((part, partIndex) => part.inlineData === undefined || part.thought === true
+                ? []
+                : [{ candidate, candidateIndex, partIndex, inlineData: part.inlineData }]));
+            const images = yield* Effect.forEach(encoded, (item) => Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(Effect.mapError((cause) => output.invalid(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`, cause)), Effect.map((data) => new GeneratedImage({
+                mediaType: item.inlineData.mimeType,
+                data,
+                providerMetadata: {
+                    google: {
+                        candidateIndex: item.candidate.index ?? item.candidateIndex,
+                        partIndex: item.partIndex,
+                        finishReason: item.candidate.finishReason,
+                        safetyRatings: item.candidate.safetyRatings,
+                        citationMetadata: item.candidate.citationMetadata,
+                        groundingMetadata: item.candidate.groundingMetadata,
+                        thoughtSignature: item.candidate.content?.parts[item.partIndex]?.thoughtSignature,
+                    },
+                },
+            }))));
+            if (images.length === 0) {
+                const finishReasons = candidates.flatMap((candidate) => candidate.finishReason === undefined ? [] : [candidate.finishReason]);
+                return yield* output.invalid(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect body for prompt feedback and candidate details`);
+            }
+            const usage = decoded.usageMetadata;
+            const outputTokens = usage?.candidatesTokenCount === undefined
+                ? undefined
+                : usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0);
+            return new ImageResponse({
+                images,
+                usage: usage === undefined
+                    ? undefined
+                    : new Usage({
+                        inputTokens: usage.promptTokenCount,
+                        outputTokens,
+                        nonCachedInputTokens: ProviderShared.subtractTokens(usage.promptTokenCount, usage.cachedContentTokenCount),
+                        cacheReadInputTokens: usage.cachedContentTokenCount,
+                        reasoningTokens: usage.thoughtsTokenCount,
+                        totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
+                        providerMetadata: { google: usage },
+                    }),
+                providerMetadata: {
+                    google: {
+                        modelVersion: decoded.modelVersion,
+                        responseId: decoded.responseId,
+                        promptFeedback: decoded.promptFeedback,
+                        candidates: candidateMetadata,
+                    },
+                },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "google", route, http: input.http });
+};
+const googleImagePart = (image) => {
+    if (image.type === "bytes")
+        return Effect.succeed({ inlineData: { mimeType: image.mediaType, data: Encoding.encodeBase64(image.data) } });
+    if (image.type === "file-uri")
+        return Effect.succeed({ fileData: { mimeType: image.mediaType, fileUri: image.uri } });
+    if (image.type === "url")
+        return ImageInputs.decodeDataUrl(image.url).pipe(Effect.flatMap((decoded) => {
+            if (decoded === undefined)
+                return Effect.fail(ImageInputs.invalid("Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI"));
+            return Effect.succeed({
+                inlineData: { mimeType: decoded.mediaType, data: Encoding.encodeBase64(decoded.data) },
+            });
+        }));
+    return Effect.fail(ImageInputs.invalid("Google generateContent requires Gemini file URIs rather than provider file IDs"));
+};
+export const GoogleImages = {
+    model,
+};

package/dist/protocols/index.d.ts

@@ -0,0 +1,12 @@
+export * as AnthropicMessages from "./anthropic-messages.js";
+export * as BedrockConverse from "./bedrock-converse.js";
+export * as Gemini from "./gemini.js";
+export * as MistralChat from "./mistral-chat.js";
+export * as OpenAIChat from "./openai-chat.js";
+export * as OpenAIImages from "./openai-images.js";
+export * as OpenAICompatibleChat from "./openai-compatible-chat.js";
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
+export * as OpenAIResponses from "./openai-responses.js";
+export * as OpenResponses from "./open-responses.js";
+export * as OpenResponsesChannel from "./open-responses-channel.js";
+export * as XAIResponses from "./xai-responses.js";

package/dist/protocols/index.js

@@ -0,0 +1,12 @@
+export * as AnthropicMessages from "./anthropic-messages.js";
+export * as BedrockConverse from "./bedrock-converse.js";
+export * as Gemini from "./gemini.js";
+export * as MistralChat from "./mistral-chat.js";
+export * as OpenAIChat from "./openai-chat.js";
+export * as OpenAIImages from "./openai-images.js";
+export * as OpenAICompatibleChat from "./openai-compatible-chat.js";
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
+export * as OpenAIResponses from "./openai-responses.js";
+export * as OpenResponses from "./open-responses.js";
+export * as OpenResponsesChannel from "./open-responses-channel.js";
+export * as XAIResponses from "./xai-responses.js";

package/dist/protocols/meta-images.d.ts

@@ -0,0 +1,26 @@
+import { ImageModel } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { type HttpOptions } from "../schema/index.js";
+type OpenString<Known extends string> = Known | (string & {});
+export type ImageOptions = {
+    readonly n?: number;
+    /** Aspect ratio hint, not an exact output resolution. */
+    readonly size?: string;
+    readonly outputFormat?: OpenString<"webp" | "png" | "jpeg">;
+    readonly responseFormat?: OpenString<"b64_json" | "url">;
+    readonly reasoningStrength?: OpenString<"low" | "high">;
+    readonly toolEnablement?: {
+        readonly enable_image_search?: boolean;
+        readonly enable_web_search?: boolean;
+        readonly enable_shell?: boolean;
+    };
+    readonly [key: string]: unknown;
+};
+export declare const model: (input: {
+    readonly id: string;
+    readonly auth: Auth.Definition;
+    readonly baseURL: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}) => ImageModel<ImageOptions>;
+export * as MetaImages from "./meta-images.js";

package/dist/protocols/meta-images.js

@@ -0,0 +1,89 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+import { JsonObject, ProviderShared, optionalNull } from "./shared.js";
+import { ImageInputs } from "./utils/image-input.js";
+const Body = Schema.StructWithRest(Schema.Struct({
+    model: Schema.String,
+    prompt: Schema.String,
+    images: Schema.optional(Schema.Array(JsonObject)),
+    n: Schema.optional(Schema.Number),
+    size: Schema.optional(Schema.String),
+    output_format: Schema.optional(Schema.String),
+    response_format: Schema.optional(Schema.String),
+    reasoning_strength: Schema.optional(Schema.String),
+    tool_enablement: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
+}), [JsonObject]);
+const Response = Schema.Struct({
+    data: Schema.Array(Schema.Struct({ b64_json: optionalNull(Schema.String), url: optionalNull(Schema.String) })),
+    output_format: Schema.optional(Schema.String),
+    usage: Schema.optional(Schema.Struct({
+        input_tokens: Schema.optional(Schema.Number),
+        output_tokens: Schema.optional(Schema.Number),
+        total_tokens: Schema.optional(Schema.Number),
+    })),
+});
+export const model = (input) => {
+    const route = {
+        id: "meta-images",
+        generate: Effect.fn("MetaImages.generate")(function* (request, execute) {
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const images = yield* Effect.forEach(request.images ?? [], (image) => {
+                if (image.type === "bytes")
+                    return Effect.succeed({ image_url: ImageInputs.dataUrl(image) });
+                if (image.type === "url")
+                    return Effect.succeed({ image_url: image.url });
+                return ImageInputs.invalid("Meta Images accepts image bytes and URLs");
+            });
+            const { outputFormat, responseFormat, reasoningStrength, toolEnablement, ...native } = request.options ?? {};
+            const payload = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(mergeJsonRecords({
+                model: request.model.id,
+                prompt: request.prompt,
+                images: images.length === 0 ? undefined : images,
+                output_format: outputFormat,
+                response_format: responseFormat,
+                reasoning_strength: reasoningStrength,
+                tool_enablement: toolEnablement,
+            }, native, http?.body));
+            const body = ProviderShared.encodeJson(payload);
+            const url = new URL(`${input.baseURL.replace(/\/$/, "")}/images/${images.length === 0 ? "generations" : "edits"}`);
+            Object.entries(http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value));
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url: url.toString(),
+                body,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url.toString()).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
+            const output = yield* ProviderShared.imageResponse("meta-images", "Meta Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(output.body).pipe(Effect.mapError((cause) => output.invalid("Meta Images returned an invalid response", cause)));
+            const format = decoded.output_format ?? payload.output_format ?? "webp";
+            const generated = yield* Effect.forEach(decoded.data, (item, index) => {
+                if (item.b64_json)
+                    return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError((cause) => output.invalid(`Meta Images result ${index} contains invalid base64`, cause)), Effect.map((data) => new GeneratedImage({ mediaType: `image/${format}`, data })));
+                if (item.url)
+                    return Effect.succeed(new GeneratedImage({ mediaType: `image/${format}`, data: item.url }));
+                return output.invalid(`Meta Images result ${index} has neither image data nor a URL`);
+            });
+            if (generated.length === 0)
+                return yield* output.invalid("Meta Images returned no images");
+            return new ImageResponse({
+                images: generated,
+                usage: decoded.usage === undefined
+                    ? undefined
+                    : new Usage({
+                        inputTokens: decoded.usage.input_tokens,
+                        outputTokens: decoded.usage.output_tokens,
+                        totalTokens: decoded.usage.total_tokens,
+                        providerMetadata: { meta: decoded.usage },
+                    }),
+                providerMetadata: { meta: { outputFormat: format } },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "meta", route, http: input.http });
+};
+export * as MetaImages from "./meta-images.js";