@opencode-ai/ai 0.0.0-beta-17492

package/dist/protocols/google-images.js

@@ -0,0 +1,191 @@
+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 { InvalidProviderOutputReason, 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 invalidOutput = (message, providerMetadata) => new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),
+});
+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 payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the Google Images response")));
+            const decoded = yield* Schema.decodeUnknownEffect(GoogleImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("Google Images returned an invalid response")));
+            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(() => invalidOutput(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`)), 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* invalidOutput(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect reason.providerMetadata.google for prompt feedback and candidate details`, {
+                    google: {
+                        promptFeedback: decoded.promptFeedback,
+                        candidates: candidateMetadata,
+                    },
+                });
+            }
+            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, ADAPTER).pipe(Effect.flatMap((decoded) => {
+            if (decoded === undefined)
+                return Effect.fail(ImageInputs.invalid(ADAPTER, "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(ADAPTER, "Google generateContent requires Gemini file URIs rather than provider file IDs"));
+};
+export const GoogleImages = {
+    model,
+};

package/dist/protocols/index.d.ts

@@ -0,0 +1,10 @@
+export * as AnthropicMessages from "./anthropic-messages.js";
+export * as BedrockConverse from "./bedrock-converse.js";
+export * as Gemini from "./gemini.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";

package/dist/protocols/index.js

@@ -0,0 +1,10 @@
+export * as AnthropicMessages from "./anthropic-messages.js";
+export * as BedrockConverse from "./bedrock-converse.js";
+export * as Gemini from "./gemini.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";

package/dist/protocols/open-responses-channel.d.ts

@@ -0,0 +1,26 @@
+import { Headers } from "effect/unstable/http";
+import { HttpTransport, type Transport, type WebSocketChannelDriver } from "../route/transport/index.js";
+export interface Options {
+    readonly id: string;
+    readonly name: string;
+    readonly rotateAfterMs?: number;
+    readonly headers?: (headers: Headers.Headers) => Headers.Headers;
+    readonly driver?: (input: {
+        readonly request: Readonly<Record<string, unknown>>;
+        readonly message: string;
+        readonly base: WebSocketChannelDriver;
+    }) => WebSocketChannelDriver;
+}
+export interface Prepared {
+    readonly http: HttpTransport.HttpPrepared<string>;
+    readonly channel?: {
+        readonly url: string;
+        readonly headers: Headers.Headers;
+        readonly rotateAfterMs?: number;
+        readonly driver: WebSocketChannelDriver;
+    };
+}
+export declare const transport: <Body>(options: Options) => Transport<Body, Prepared, string>;
+export declare const OpenResponsesChannel: {
+    readonly transport: <Body>(options: Options) => Transport<Body, Prepared, string>;
+};

package/dist/protocols/open-responses-channel.js

@@ -0,0 +1,120 @@
+import { Effect, Schema, Stream } from "effect";
+import { Headers } from "effect/unstable/http";
+import { Framing } from "../route/framing.js";
+import { HttpTransport, WebSocketTransport, } from "../route/transport/index.js";
+import * as ProviderShared from "./shared.js";
+import { OpenResponses } from "./open-responses.js";
+const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Schema.tag("response.create") }), [
+    Schema.Record(Schema.String, Schema.Unknown),
+]);
+const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate));
+const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate));
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event);
+const message = (body) => Effect.gen(function* () {
+    if (!ProviderShared.isRecord(body))
+        return yield* ProviderShared.invalidRequest("Open Responses WebSocket body must be a JSON object");
+    const { stream: _stream, stream_options: _streamOptions, background: _background, ...request } = body;
+    const decoded = yield* decodeMessage({ ...request, type: "response.create" });
+    return { request: decoded, message: encodeMessage(decoded) };
+});
+const driver = (options, body) => {
+    let responseID;
+    let terminal = false;
+    return {
+        create: () => Effect.sync(() => {
+            responseID = undefined;
+            terminal = false;
+            return { message: body, mode: "full" };
+        }),
+        observe: (_create, frame) => Effect.gen(function* () {
+            const event = yield* decodeEvent(frame).pipe(Effect.mapError(() => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame)));
+            if (terminal)
+                return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} after a terminal event`, frame);
+            if (event.type === "error") {
+                terminal = true;
+                yield* OpenResponses.decodeKnownErrorEvent(event).pipe(Effect.mapError(() => ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame)));
+                return {
+                    type: "provider-failure",
+                    error: OpenResponses.providerFailure(options.id, event, `${options.name} stream error`),
+                };
+            }
+            if (event.type === "response.failed") {
+                terminal = true;
+                if (responseID && event.response?.id && event.response.id !== responseID)
+                    return yield* ProviderShared.eventError(options.id, `${options.name} response ID changed during execution`, frame);
+                return {
+                    type: "provider-failure",
+                    error: OpenResponses.providerFailure(options.id, event, `${options.name} response failed`),
+                };
+            }
+            if (event.type === "response.created") {
+                const created = event.response?.id;
+                if (responseID)
+                    return yield* ProviderShared.eventError(options.id, `${options.name} emitted duplicate response.created`, frame);
+                if (!created)
+                    return yield* ProviderShared.eventError(options.id, `${options.name} response.created is missing response.id`, frame);
+                responseID = created;
+                return { type: "frame", frame };
+            }
+            if (!responseID)
+                return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} before response.created`, frame);
+            if (event.response?.id && event.response.id !== responseID)
+                return yield* ProviderShared.eventError(options.id, `${options.name} response ID changed during execution`, frame);
+            if (event.type === "response.completed") {
+                terminal = true;
+                return { type: "completed", frame };
+            }
+            if (event.type === "response.incomplete") {
+                terminal = true;
+                return { type: "incomplete", frame };
+            }
+            return { type: "frame", frame };
+        }),
+    };
+};
+export const transport = (options) => {
+    const http = HttpTransport.sseJson.with();
+    return {
+        id: http.id,
+        prepare: (input) => Effect.gen(function* () {
+            const parts = yield* HttpTransport.jsonRequestParts(input);
+            const headers = Headers.remove(options.headers?.(parts.headers) ?? parts.headers, "content-length");
+            const channel = input.webSocket
+                ? yield* Effect.gen(function* () {
+                    const create = yield* message(parts.jsonBody);
+                    const base = driver(options, create.message);
+                    return {
+                        url: yield* WebSocketTransport.toWebSocketUrl(parts.url),
+                        headers,
+                        rotateAfterMs: options.rotateAfterMs,
+                        driver: options.driver?.({ request: create.request, message: create.message, base }) ?? base,
+                    };
+                })
+                : undefined;
+            return {
+                http: {
+                    request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
+                    framing: Framing.sse,
+                    middleware: input.middleware,
+                },
+                channel,
+            };
+        }),
+        execute: (prepared, request, runtime, executeOptions) => {
+            if (!executeOptions?.webSocket || !prepared.channel)
+                return http.execute(prepared.http, request, runtime);
+            const exchange = {
+                id: request.id ?? "request",
+                connect: {
+                    url: prepared.channel.url,
+                    headers: prepared.channel.headers,
+                    rotateAfterMs: prepared.channel.rotateAfterMs,
+                },
+                fallback: () => Stream.unwrap(http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => execution.frames))),
+                driver: prepared.channel.driver,
+            };
+            return executeOptions.webSocket.execute(exchange);
+        },
+    };
+};
+export const OpenResponsesChannel = { transport };