@opencode/ai 0.0.0-reserved → 2.0.1

package/dist/protocols/bedrock-event-stream.js

@@ -0,0 +1,97 @@
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { Effect, Encoding, Stream } from "effect";
+import { AIError, AIErrorReason, InvalidProviderOutputError } from "../schema/index.js";
+import { Framing } from "../route/framing.js";
+import { ProviderShared } from "./shared.js";
+// Bedrock streams responses using the AWS event stream binary protocol — each
+// frame is `[length:4][headers-length:4][prelude-crc:4][headers][payload][crc:4]`.
+// We use `@smithy/eventstream-codec` to validate framing and CRCs, then
+// reconstruct the JSON wrapping by `:event-type` so the chunk schema can match.
+const eventCodec = new EventStreamCodec(toUtf8, fromUtf8);
+const utf8 = new TextDecoder();
+const initialFrameBuffer = { buffer: new Uint8Array(0), offset: 0 };
+const endOfStream = { _tag: "End" };
+const appendChunk = (state, chunk) => {
+    const remaining = state.buffer.length - state.offset;
+    // Compact: drop the consumed prefix and append the new chunk in one alloc.
+    // This bounds buffer growth to at most one network chunk past the live
+    // window, regardless of stream length.
+    const next = new Uint8Array(remaining + chunk.length);
+    next.set(state.buffer.subarray(state.offset), 0);
+    next.set(chunk, remaining);
+    return { buffer: next, offset: 0 };
+};
+const consumeFrames = (route) => (state, input) => Effect.gen(function* () {
+    if (input._tag === "End") {
+        const remaining = state.buffer.subarray(state.offset);
+        if (remaining.length > 0)
+            return yield* new AIError({
+                reason: new InvalidProviderOutputError({
+                    route,
+                    classification: "incomplete-stream",
+                    message: `Incomplete Bedrock Converse event-stream frame: ${remaining.length} buffered bytes remain at end of stream`,
+                    body: Encoding.encodeBase64(remaining),
+                }),
+            });
+        return [state, []];
+    }
+    let cursor = appendChunk(state, input.bytes);
+    const out = [];
+    while (cursor.buffer.length - cursor.offset >= 4) {
+        const view = cursor.buffer.subarray(cursor.offset);
+        const totalLength = new DataView(view.buffer, view.byteOffset, view.byteLength).getUint32(0, false);
+        if (view.length < totalLength)
+            break;
+        const decoded = yield* Effect.try({
+            try: () => eventCodec.decode(view.subarray(0, totalLength)),
+            catch: (error) => ProviderShared.eventError(route, `Failed to decode Bedrock Converse event-stream frame: ${error instanceof Error ? error.message : String(error)}`, Encoding.encodeBase64(view.subarray(0, totalLength)), error),
+        });
+        cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength };
+        const payload = utf8.decode(decoded.body);
+        const body = ProviderShared.encodeJson({ headers: decoded.headers, body: payload });
+        const messageType = decoded.headers[":message-type"]?.value;
+        if (messageType === "error") {
+            const code = decoded.headers[":error-code"]?.value;
+            const message = decoded.headers[":error-message"]?.value;
+            return yield* ProviderShared.eventError(route, [code, message].filter((value) => typeof value === "string").join(": ") ||
+                "Bedrock Converse event-stream error", body);
+        }
+        const eventType = messageType === "event"
+            ? decoded.headers[":event-type"]?.value
+            : messageType === "exception"
+                ? decoded.headers[":exception-type"]?.value
+                : undefined;
+        if (typeof eventType !== "string")
+            continue;
+        if (!payload)
+            continue;
+        // The AWS event stream pads short payloads with a `p` field. Drop it
+        // before handing the object to the chunk schema. JSON decode goes
+        // through the shared Schema-driven codec to satisfy the package rule
+        // against ad-hoc `JSON.parse` calls.
+        const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload").pipe(Effect.mapError((error) => new AIError({
+            reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
+        }))));
+        delete parsed.p;
+        out.push({
+            ...(messageType === "exception"
+                ? { exception: { type: eventType, details: parsed } }
+                : { [eventType]: parsed }),
+            rawBody: body,
+        });
+    }
+    return [cursor, out];
+});
+/**
+ * AWS event-stream framing for Bedrock Converse. Each frame is decoded by
+ * `@smithy/eventstream-codec` (length + header + payload + CRC) and rewrapped
+ * under its `:event-type` header so the chunk schema can match the JSON
+ * payload directly.
+ */
+export const framing = (route) => ({
+    id: "aws-event-stream",
+    body: (frame) => ("rawBody" in frame && typeof frame.rawBody === "string" ? frame.rawBody : undefined),
+    frame: (bytes) => bytes.pipe(Stream.map((bytes) => ({ _tag: "Chunk", bytes })), Stream.concat(Stream.succeed(endOfStream)), Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
+});
+export * as BedrockEventStream from "./bedrock-event-stream.js";

package/dist/protocols/gemini.d.ts

@@ -0,0 +1,285 @@
+import { Schema } from "effect";
+import { Route } from "../route/client.js";
+import { Protocol } from "../route/protocol.js";
+import { Lifecycle } from "./utils/lifecycle.js";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+export interface OptionsInput {
+    readonly [key: string]: unknown;
+    readonly cachedContent?: string;
+    readonly safetySettings?: ReadonlyArray<{
+        readonly category: "HARM_CATEGORY_UNSPECIFIED" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_DANGEROUS_CONTENT" | "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_CIVIC_INTEGRITY" | (string & {});
+        readonly threshold: "HARM_BLOCK_THRESHOLD_UNSPECIFIED" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH" | "BLOCK_NONE" | "OFF" | (string & {});
+    }>;
+    readonly serviceTier?: "standard" | "flex" | "priority" | (string & {});
+    readonly thinkingConfig?: {
+        readonly thinkingBudget?: number;
+        readonly includeThoughts?: boolean;
+        readonly thinkingLevel?: "minimal" | "low" | "medium" | "high" | (string & {});
+    };
+}
+export type ProviderOptionsInput = OptionsInput;
+declare const GeminiBody: Schema.Struct<{
+    cachedContent: Schema.optional<Schema.String>;
+    contents: Schema.$Array<Schema.Struct<{
+        readonly role: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["user", "model"]>>>;
+        readonly parts: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly text: Schema.String;
+            readonly thought: Schema.optional<Schema.NullOr<Schema.Boolean>>;
+            readonly thoughtSignature: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>, Schema.Struct<{
+            readonly inlineData: Schema.Struct<{
+                readonly mimeType: Schema.String;
+                readonly data: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly functionCall: Schema.Struct<{
+                readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly name: Schema.String;
+                readonly args: Schema.optional<Schema.Unknown>;
+            }>;
+            readonly thoughtSignature: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>, Schema.Struct<{
+            readonly functionResponse: Schema.Struct<{
+                readonly id: Schema.optional<Schema.String>;
+                readonly name: Schema.String;
+                readonly response: Schema.Unknown;
+                readonly parts: Schema.optional<Schema.$Array<Schema.Struct<{
+                    readonly inlineData: Schema.Struct<{
+                        readonly mimeType: Schema.String;
+                        readonly data: Schema.String;
+                    }>;
+                }>>>;
+            }>;
+        }>]>>>>;
+    }>>;
+    labels: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    safetySettings: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly category: Schema.String;
+        readonly threshold: Schema.String;
+    }>>>;
+    serviceTier: Schema.optional<Schema.String>;
+    systemInstruction: Schema.optional<Schema.Struct<{
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly text: Schema.String;
+        }>>;
+    }>>;
+    tools: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly functionDeclarations: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly parameters: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+        }>>;
+    }>>>;
+    toolConfig: Schema.optional<Schema.Struct<{
+        readonly functionCallingConfig: Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["AUTO", "NONE", "ANY"]>;
+            readonly allowedFunctionNames: Schema.optional<Schema.$Array<Schema.String>>;
+        }>;
+    }>>;
+    generationConfig: Schema.optional<Schema.Struct<{
+        readonly maxOutputTokens: Schema.optional<Schema.Number>;
+        readonly temperature: Schema.optional<Schema.Number>;
+        readonly topP: Schema.optional<Schema.Number>;
+        readonly topK: Schema.optional<Schema.Number>;
+        readonly frequencyPenalty: Schema.optional<Schema.Number>;
+        readonly presencePenalty: Schema.optional<Schema.Number>;
+        readonly seed: Schema.optional<Schema.Number>;
+        readonly stopSequences: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly thinkingConfig: Schema.optional<Schema.Struct<{
+            readonly thinkingBudget: Schema.optional<Schema.Number>;
+            readonly includeThoughts: Schema.optional<Schema.Boolean>;
+            readonly thinkingLevel: Schema.optional<Schema.String>;
+        }>>;
+    }>>;
+}>;
+export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>;
+/**
+ * The Gemini protocol — request body construction, body schema, and the
+ * streaming-event state machine shared by Google AI Studio and Vertex Gemini.
+ */
+export declare const protocol: Protocol<{
+    readonly contents: readonly {
+        readonly parts?: readonly ({
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly id?: string | null | undefined;
+                readonly args?: unknown;
+            };
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionResponse: {
+                readonly name: string;
+                readonly response: unknown;
+                readonly id?: string | undefined;
+                readonly parts?: readonly {
+                    readonly inlineData: {
+                        readonly mimeType: string;
+                        readonly data: string;
+                    };
+                }[] | undefined;
+            };
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
+    }[];
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        }[];
+    }[] | undefined;
+    readonly serviceTier?: string | undefined;
+    readonly toolConfig?: {
+        readonly functionCallingConfig: {
+            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly allowedFunctionNames?: readonly string[] | undefined;
+        };
+    } | undefined;
+    readonly cachedContent?: string | undefined;
+    readonly safetySettings?: readonly {
+        readonly category: string;
+        readonly threshold: string;
+    }[] | undefined;
+    readonly labels?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly systemInstruction?: {
+        readonly parts: readonly {
+            readonly text: string;
+        }[];
+    } | undefined;
+    readonly generationConfig?: {
+        readonly temperature?: number | undefined;
+        readonly topP?: number | undefined;
+        readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
+        readonly stopSequences?: readonly string[] | undefined;
+        readonly thinkingConfig?: {
+            readonly thinkingBudget?: number | undefined;
+            readonly includeThoughts?: boolean | undefined;
+            readonly thinkingLevel?: string | undefined;
+        } | undefined;
+        readonly maxOutputTokens?: number | undefined;
+    } | undefined;
+}, string, {
+    readonly error?: unknown;
+    readonly candidates?: readonly {
+        readonly content?: {
+            readonly parts?: readonly unknown[] | null | undefined;
+            readonly role?: "model" | "user" | null | undefined;
+        } | null | undefined;
+        readonly finishReason?: string | null | undefined;
+    }[] | null | undefined;
+    readonly promptFeedback?: {
+        readonly [x: string]: unknown;
+        readonly blockReason?: string | null | undefined;
+        readonly blockReasonMessage?: string | null | undefined;
+        readonly safetyRatings?: unknown;
+    } | null | undefined;
+    readonly usageMetadata?: {
+        readonly cachedContentTokenCount?: number | null | undefined;
+        readonly thoughtsTokenCount?: number | null | undefined;
+        readonly promptTokenCount?: number | null | undefined;
+        readonly candidatesTokenCount?: number | null | undefined;
+        readonly totalTokenCount?: number | null | undefined;
+    } | null | undefined;
+}, {
+    route: string;
+    providerMetadataKey: string;
+    hasToolCalls: boolean;
+    lifecycle: Lifecycle.State;
+    nextReasoningId: number;
+    nextTextId: number;
+}>;
+export declare const route: Route<{
+    readonly contents: readonly {
+        readonly parts?: readonly ({
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly id?: string | null | undefined;
+                readonly args?: unknown;
+            };
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionResponse: {
+                readonly name: string;
+                readonly response: unknown;
+                readonly id?: string | undefined;
+                readonly parts?: readonly {
+                    readonly inlineData: {
+                        readonly mimeType: string;
+                        readonly data: string;
+                    };
+                }[] | undefined;
+            };
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
+    }[];
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        }[];
+    }[] | undefined;
+    readonly serviceTier?: string | undefined;
+    readonly toolConfig?: {
+        readonly functionCallingConfig: {
+            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly allowedFunctionNames?: readonly string[] | undefined;
+        };
+    } | undefined;
+    readonly cachedContent?: string | undefined;
+    readonly safetySettings?: readonly {
+        readonly category: string;
+        readonly threshold: string;
+    }[] | undefined;
+    readonly labels?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly systemInstruction?: {
+        readonly parts: readonly {
+            readonly text: string;
+        }[];
+    } | undefined;
+    readonly generationConfig?: {
+        readonly temperature?: number | undefined;
+        readonly topP?: number | undefined;
+        readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
+        readonly stopSequences?: readonly string[] | undefined;
+        readonly thinkingConfig?: {
+            readonly thinkingBudget?: number | undefined;
+            readonly includeThoughts?: boolean | undefined;
+            readonly thinkingLevel?: string | undefined;
+        } | undefined;
+        readonly maxOutputTokens?: number | undefined;
+    } | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>;
+export * as Gemini from "./gemini.js";