@opencode-ai/ai 0.0.0-next-16149 → 0.0.0-next-16153

package/dist/llm.d.ts

@@ -1,27 +1,20 @@
 import { Effect, JsonSchema, Schema } from "effect";
-import { GenerationOptions, HttpOptions, LLMError, LLMRequest, LLMResponse, Message, type ModelInput as SchemaModelInput, SystemPart, ToolChoice, ToolDefinition, type ContentPart, ToolResultPart } from "./schema";
+import { GenerationOptions, HttpOptions, LLMError, LLMRequest, LLMResponse, Message, SystemPart, ToolChoice, ToolDefinition, type ContentPart } from "./schema";
 import { type ToolSchema } from "./tool";
-export type ModelInput = SchemaModelInput;
-export type MessageInput = Message.Input;
-export type ToolChoiceInput = ToolChoice.Input;
-export type ToolChoiceMode = ToolChoice.Mode;
-export type ToolResultInput = Parameters<typeof ToolResultPart.make>[0];
 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
 export type RequestInput = Omit<ConstructorParameters<typeof LLMRequest>[0], "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
     readonly system?: string | SystemPart | ReadonlyArray<SystemPart>;
     readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>;
-    readonly messages?: ReadonlyArray<Message | MessageInput>;
+    readonly messages?: ReadonlyArray<Message | Message.Input>;
     readonly tools?: ReadonlyArray<ToolDefinition.Input>;
-    readonly toolChoice?: ToolChoiceInput;
+    readonly toolChoice?: ToolChoice.Input;
     readonly generation?: GenerationOptions.Input;
     readonly providerOptions?: ConstructorParameters<typeof LLMRequest>[0]["providerOptions"];
     readonly http?: HttpOptions.Input;
 };
 export declare const generate: typeof import("./route/client").generate;
 export declare const stream: typeof import("./route/client").stream;
-export declare const requestInput: (input: LLMRequest) => RequestInput;
 export declare const request: (input: RequestInput) => LLMRequest;
-export declare const updateRequest: (input: LLMRequest, patch: Partial<RequestInput>) => LLMRequest;
 type GenerateObjectBase = Omit<RequestInput, "tools" | "toolChoice">;
 export declare class GenerateObjectResponse<T> {
     readonly object: T;

package/dist/llm.js

@@ -1,12 +1,9 @@
 import { Effect, JsonSchema, Schema } from "effect";
 import { LLMClient } from "./route/client";
-import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, LLMError, LLMEvent, LLMRequest, LLMResponse, Message, SystemPart, ToolChoice, ToolDefinition, ToolResultPart, } from "./schema";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, LLMError, LLMEvent, LLMRequest, LLMResponse, Message, SystemPart, ToolChoice, ToolDefinition, } from "./schema";
 import { make as makeTool, toDefinitions } from "./tool";
 export const generate = LLMClient.generate;
 export const stream = LLMClient.stream;
-export const requestInput = (input) => ({
-    ...LLMRequest.input(input),
-});
 export const request = (input) => {
     const { system: requestSystem, prompt, messages, tools, toolChoice: requestToolChoice, generation: requestGeneration, providerOptions: requestProviderOptions, http: requestHttp, ...rest } = input;
     return new LLMRequest({
@@ -20,7 +17,6 @@ export const request = (input) => {
         http: requestHttp === undefined ? undefined : HttpOptions.make(requestHttp),
     });
 };
-export const updateRequest = (input, patch) => request({ ...requestInput(input), ...patch });
 const GENERATE_OBJECT_TOOL_NAME = "generate_object";
 const GENERATE_OBJECT_TOOL_DESCRIPTION = "Return the structured result by calling this tool.";
 export class GenerateObjectResponse {

package/dist/protocols/anthropic-messages.d.ts

@@ -1,10 +1,33 @@
 import { Schema } from "effect";
 import { Route } from "../route/client";
 import { Protocol } from "../route/protocol";
+import { type ProviderOptions } from "../schema";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolStream } from "./utils/tool-stream";
 export declare const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export declare const PATH = "/messages";
+export type ThinkingInput = {
+    readonly type: "adaptive";
+    readonly display?: "summarized" | "omitted";
+} | {
+    readonly type: "disabled";
+} | ({
+    readonly type: "enabled";
+} & ({
+    readonly budgetTokens: number;
+    readonly budget_tokens?: number;
+} | {
+    readonly budgetTokens?: number;
+    readonly budget_tokens: number;
+}));
+export interface OptionsInput {
+    readonly [key: string]: unknown;
+    readonly thinking?: ThinkingInput;
+    readonly effort?: string;
+}
+export type ProviderOptionsInput = ProviderOptions & {
+    readonly anthropic?: OptionsInput;
+};
 export declare const AnthropicMessagesBody: Schema.Struct<{
     model: Schema.String;
     system: Schema.optional<Schema.$Array<Schema.Struct<{

package/dist/protocols/anthropic-messages.js

@@ -8,7 +8,6 @@ import { LLMError, LLMEvent, Usage, } from "../schema";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared";
 import { classifyProviderFailure } from "../provider-error";
 import * as Cache from "./utils/cache";
-import { AnthropicOptions } from "./utils/anthropic-options";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolSchemaProjection } from "./utils/tool-schema";
 import { ToolStream } from "./utils/tool-stream";
@@ -130,6 +129,19 @@ const AnthropicToolChoice = Schema.Union([
     Schema.Struct({ type: Schema.Literals(["auto", "any", "none"]) }),
     Schema.Struct({ type: Schema.tag("tool"), name: Schema.String }),
 ]);
+const AnthropicThinking = Schema.Union([
+    Schema.Struct({
+        type: Schema.tag("enabled"),
+        budget_tokens: Schema.Number,
+    }),
+    Schema.Struct({
+        type: Schema.tag("adaptive"),
+        display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
+    }),
+    Schema.Struct({
+        type: Schema.tag("disabled"),
+    }),
+]);
 const AnthropicOutputConfig = Schema.Struct({
     effort: Schema.optional(Schema.String),
 });
@@ -145,7 +157,7 @@ const AnthropicBodyFields = {
     top_p: Schema.optional(Schema.Number),
     top_k: Schema.optional(Schema.Number),
     stop_sequences: optionalArray(Schema.String),
-    thinking: Schema.optional(AnthropicOptions.ThinkingSchema),
+    thinking: Schema.optional(AnthropicThinking),
     output_config: Schema.optional(AnthropicOutputConfig),
 };
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields);
@@ -433,6 +445,37 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
     }
     return messages;
 });
+const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request) {
+    const input = request.providerOptions?.anthropic;
+    return {
+        thinking: yield* resolveThinking(input?.thinking),
+        effort: typeof input?.effort === "string" ? input.effort : undefined,
+    };
+});
+const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
+    if (!ProviderShared.isRecord(input))
+        return undefined;
+    if (input.type === "adaptive") {
+        const display = input.display === "summarized"
+            ? "summarized"
+            : input.display === "omitted"
+                ? "omitted"
+                : undefined;
+        return { type: "adaptive", ...(display === undefined ? {} : { display }) };
+    }
+    if (input.type === "disabled")
+        return { type: "disabled" };
+    if (input.type !== "enabled")
+        return undefined;
+    const budget = typeof input.budgetTokens === "number"
+        ? input.budgetTokens
+        : typeof input.budget_tokens === "number"
+            ? input.budget_tokens
+            : undefined;
+    if (budget === undefined)
+        return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens");
+    return { type: "enabled", budget_tokens: budget };
+});
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const generation = request.generation;
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
@@ -457,7 +500,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     if (breakpoints.dropped > 0) {
         yield* Effect.logWarning(`Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`);
     }
-    const options = yield* AnthropicOptions.resolve(request);
+    const options = yield* resolveOptions(request);
     return {
         model: request.model.id,
         system,

package/dist/protocols/gemini.d.ts

@@ -1,8 +1,19 @@
 import { Schema } from "effect";
 import { Route } from "../route/client";
 import { Protocol } from "../route/protocol";
+import { type ProviderOptions } from "../schema";
 import { Lifecycle } from "./utils/lifecycle";
 export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+export interface OptionsInput {
+    readonly [key: string]: unknown;
+    readonly thinkingConfig?: {
+        readonly thinkingBudget?: number;
+        readonly includeThoughts?: boolean;
+    };
+}
+export type ProviderOptionsInput = ProviderOptions & {
+    readonly gemini?: OptionsInput;
+};
 declare const GeminiBody: Schema.Struct<{
     contents: Schema.$Array<Schema.Struct<{
         readonly role: Schema.Literals<readonly ["user", "model"]>;

package/dist/protocols/gemini.js

@@ -6,7 +6,6 @@ import { Framing } from "../route/framing";
 import { Protocol } from "../route/protocol";
 import { LLMEvent, Usage, } from "../schema";
 import { JsonObject, optionalArray, ProviderShared } from "./shared";
-import { GeminiOptions } from "./utils/gemini-options";
 import { GeminiToolSchema } from "./utils/gemini-tool-schema";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolSchemaProjection } from "./utils/tool-schema";
@@ -70,13 +69,17 @@ const GeminiToolConfig = Schema.Struct({
         allowedFunctionNames: optionalArray(Schema.String),
     }),
 });
+const GeminiThinkingConfig = Schema.Struct({
+    thinkingBudget: Schema.optional(Schema.Number),
+    includeThoughts: Schema.optional(Schema.Boolean),
+});
 const GeminiGenerationConfig = Schema.Struct({
     maxOutputTokens: Schema.optional(Schema.Number),
     temperature: Schema.optional(Schema.Number),
     topP: Schema.optional(Schema.Number),
     topK: Schema.optional(Schema.Number),
     stopSequences: optionalArray(Schema.String),
-    thinkingConfig: Schema.optional(GeminiOptions.ThinkingConfigSchema),
+    thinkingConfig: Schema.optional(GeminiThinkingConfig),
 });
 const GeminiBodyFields = {
     contents: Schema.Array(GeminiContent),
@@ -243,10 +246,22 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
     }
     return contents;
 });
+const resolveOptions = (request) => {
+    const value = request.providerOptions?.gemini?.thinkingConfig;
+    if (!ProviderShared.isRecord(value))
+        return {};
+    const thinkingConfig = {
+        thinkingBudget: typeof value.thinkingBudget === "number" ? value.thinkingBudget : undefined,
+        includeThoughts: typeof value.includeThoughts === "boolean" ? value.includeThoughts : undefined,
+    };
+    return {
+        thinkingConfig: Object.values(thinkingConfig).some((item) => item !== undefined) ? thinkingConfig : undefined,
+    };
+};
 const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
     const hasTools = request.tools.length > 0;
     const generation = request.generation;
-    const options = GeminiOptions.resolve(request);
+    const options = resolveOptions(request);
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     const generationConfig = {
         maxOutputTokens: generation?.maxTokens,

package/dist/providers/anthropic-compatible.d.ts

@@ -1,14 +1,16 @@
 import type { ProviderPackage } from "../provider-package";
+import { AnthropicMessages } from "../protocols/anthropic-messages";
 import type { ProviderAuthOption } from "../route/auth-options";
 import type { RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
-import type { AnthropicProviderOptionsInput } from "./anthropic-options";
-export type { AnthropicOptionsInput, AnthropicProviderOptionsInput, AnthropicThinkingInput } from "./anthropic-options";
+export type AnthropicOptionsInput = AnthropicMessages.OptionsInput;
+export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput;
+export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput;
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly provider?: string;
     readonly baseURL: string;
-    readonly providerOptions?: AnthropicProviderOptionsInput;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export type Settings = ProviderPackage.Settings & ({
     readonly apiKey?: string;
@@ -19,7 +21,7 @@ export type Settings = ProviderPackage.Settings & ({
 }) & {
     readonly baseURL: string;
     readonly provider?: string;
-    readonly providerOptions?: AnthropicProviderOptionsInput;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export declare const routes: import("../route").Route<{
     readonly messages: readonly (import("effect/Schema").Struct.ReadonlySide<{

package/dist/providers/anthropic.d.ts

@@ -2,8 +2,10 @@ import type { RouteDefaultsInput } from "../route/client";
 import type { ProviderAuthOption } from "../route/auth-options";
 import type { ProviderPackage } from "../provider-package";
 import { type ModelID } from "../schema";
-import type { AnthropicProviderOptionsInput } from "./anthropic-options";
-export type { AnthropicOptionsInput, AnthropicProviderOptionsInput, AnthropicThinkingInput } from "./anthropic-options";
+import { AnthropicMessages } from "../protocols/anthropic-messages";
+export type AnthropicOptionsInput = AnthropicMessages.OptionsInput;
+export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput;
+export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput;
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export declare const routes: import("../route").Route<{
     readonly messages: readonly (import("effect/Schema").Struct.ReadonlySide<{
@@ -185,7 +187,7 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
-    readonly providerOptions?: AnthropicProviderOptionsInput;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export type Settings = ProviderPackage.Settings & ({
     readonly apiKey?: string;
@@ -195,7 +197,7 @@ export type Settings = ProviderPackage.Settings & ({
     readonly authToken?: string;
 }) & {
     readonly baseURL?: string;
-    readonly providerOptions?: AnthropicProviderOptionsInput;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;

package/dist/providers/google-vertex-messages.d.ts

@@ -1,16 +1,18 @@
 import { Schema } from "effect";
 import type { ProviderPackage } from "../provider-package";
+import { AnthropicMessages } from "../protocols/anthropic-messages";
 import { Route, type RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
-import type { AnthropicProviderOptionsInput } from "./anthropic-options";
 import { GoogleVertexShared } from "./google-vertex-shared";
-export type { AnthropicOptionsInput, AnthropicProviderOptionsInput, AnthropicThinkingInput } from "./anthropic-options";
+export type AnthropicOptionsInput = AnthropicMessages.OptionsInput;
+export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput;
+export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput;
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: AnthropicProviderOptionsInput;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export interface Settings extends ProviderPackage.Settings {
     readonly accessToken?: string;
@@ -18,7 +20,7 @@ export interface Settings extends ProviderPackage.Settings {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: AnthropicProviderOptionsInput;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 }
 export declare const routes: Route<{
     anthropic_version: "vertex-2023-10-16";

package/dist/providers/google-vertex.d.ts

@@ -1,15 +1,16 @@
 import type { ProviderPackage } from "../provider-package";
+import { Gemini } from "../protocols/gemini";
 import { Route, type RouteDefaultsInput } from "../route/client";
 import { type ModelID } from "../schema";
-import type { GeminiProviderOptionsInput } from "./gemini-options";
 import { GoogleVertexShared } from "./google-vertex-shared";
-export type { GeminiOptionsInput, GeminiProviderOptionsInput } from "./gemini-options";
+export type GeminiOptionsInput = Gemini.OptionsInput;
+export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.ApiKeyOptions & {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: GeminiProviderOptionsInput;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
 };
 export type Settings = ProviderPackage.Settings & ({
     readonly accessToken?: string;
@@ -21,7 +22,7 @@ export type Settings = ProviderPackage.Settings & ({
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: GeminiProviderOptionsInput;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
 };
 export declare const routes: Route<{
     readonly contents: readonly import("effect/Schema").Struct.ReadonlySide<{

package/dist/providers/google.d.ts

@@ -2,9 +2,10 @@ import type { RouteDefaultsInput } from "../route/client";
 import type { ProviderAuthOption } from "../route/auth-options";
 import type { ProviderPackage } from "../provider-package";
 import { type ModelID } from "../schema";
-import type { GeminiProviderOptionsInput } from "./gemini-options";
+import { Gemini } from "../protocols/gemini";
 export type { GoogleImageOptions } from "../protocols/google-images";
-export type { GeminiOptionsInput, GeminiProviderOptionsInput } from "./gemini-options";
+export type GeminiOptionsInput = Gemini.OptionsInput;
+export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
 export declare const routes: import("../route").Route<{
     readonly contents: readonly import("effect/Schema").Struct.ReadonlySide<{
@@ -71,12 +72,12 @@ export declare const routes: import("../route").Route<{
 }, import("../route/transport/http").HttpPrepared<string>>[];
 export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
-    readonly providerOptions?: GeminiProviderOptionsInput;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
 };
 export interface Settings extends ProviderPackage.Settings {
     readonly apiKey?: string;
     readonly baseURL?: string;
-    readonly providerOptions?: GeminiProviderOptionsInput;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
 }
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"LLM.ProviderID">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-16149",
+  "version": "0.0.0-next-16153",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.98",
-    "@opencode-ai/http-recorder": "0.0.0-next-16149",
+    "@opencode-ai/http-recorder": "0.0.0-next-16153",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-next-16149",
+    "@opencode-ai/schema": "0.0.0-next-16153",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.98",
     "google-auth-library": "10.5.0"

package/dist/protocols/utils/anthropic-options.d.ts

@@ -1,31 +0,0 @@
-import { Effect, Schema } from "effect";
-import type { LLMRequest } from "../../schema";
-export declare const ThinkingSchema: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.tag<"enabled">;
-    readonly budget_tokens: Schema.Number;
-}>, Schema.Struct<{
-    readonly type: Schema.tag<"adaptive">;
-    readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
-}>, Schema.Struct<{
-    readonly type: Schema.tag<"disabled">;
-}>]>;
-export type Thinking = Schema.Schema.Type<typeof ThinkingSchema>;
-export interface Resolved {
-    readonly thinking?: Thinking;
-    readonly effort?: string;
-}
-export declare const resolve: (request: LLMRequest) => Effect.Effect<{
-    thinking: {
-        display?: "summarized" | "omitted" | undefined;
-        type: "adaptive";
-        budget_tokens?: undefined;
-    } | {
-        type: "disabled";
-        budget_tokens?: undefined;
-    } | {
-        type: "enabled";
-        budget_tokens: number;
-    } | undefined;
-    effort: string | undefined;
-}, import("../..").LLMError, never>;
-export * as AnthropicOptions from "./anthropic-options";

package/dist/protocols/utils/anthropic-options.js

@@ -1,47 +0,0 @@
-import { Effect, Schema } from "effect";
-import { ProviderShared } from "../shared";
-export const ThinkingSchema = Schema.Union([
-    Schema.Struct({
-        type: Schema.tag("enabled"),
-        budget_tokens: Schema.Number,
-    }),
-    Schema.Struct({
-        type: Schema.tag("adaptive"),
-        display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
-    }),
-    Schema.Struct({
-        type: Schema.tag("disabled"),
-    }),
-]);
-export const resolve = Effect.fn("AnthropicOptions.resolve")(function* (request) {
-    const input = request.providerOptions?.anthropic;
-    return {
-        thinking: yield* resolveThinking(input?.thinking),
-        effort: typeof input?.effort === "string" ? input.effort : undefined,
-    };
-});
-const resolveThinking = Effect.fn("AnthropicOptions.resolveThinking")(function* (input) {
-    if (!ProviderShared.isRecord(input))
-        return undefined;
-    if (input.type === "adaptive") {
-        const display = input.display === "summarized"
-            ? "summarized"
-            : input.display === "omitted"
-                ? "omitted"
-                : undefined;
-        return { type: "adaptive", ...(display === undefined ? {} : { display }) };
-    }
-    if (input.type === "disabled")
-        return { type: "disabled" };
-    if (input.type !== "enabled")
-        return undefined;
-    const budget = typeof input.budgetTokens === "number"
-        ? input.budgetTokens
-        : typeof input.budget_tokens === "number"
-            ? input.budget_tokens
-            : undefined;
-    if (budget === undefined)
-        return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens");
-    return { type: "enabled", budget_tokens: budget };
-});
-export * as AnthropicOptions from "./anthropic-options";

package/dist/protocols/utils/gemini-options.d.ts

@@ -1,12 +0,0 @@
-import { Schema } from "effect";
-import type { LLMRequest } from "../../schema";
-export declare const ThinkingConfigSchema: Schema.Struct<{
-    readonly thinkingBudget: Schema.optional<Schema.Number>;
-    readonly includeThoughts: Schema.optional<Schema.Boolean>;
-}>;
-export type ThinkingConfig = Schema.Schema.Type<typeof ThinkingConfigSchema>;
-export interface Resolved {
-    readonly thinkingConfig?: ThinkingConfig;
-}
-export declare const resolve: (request: LLMRequest) => Resolved;
-export * as GeminiOptions from "./gemini-options";

package/dist/protocols/utils/gemini-options.js

@@ -1,19 +0,0 @@
-import { Schema } from "effect";
-import { ProviderShared } from "../shared";
-export const ThinkingConfigSchema = Schema.Struct({
-    thinkingBudget: Schema.optional(Schema.Number),
-    includeThoughts: Schema.optional(Schema.Boolean),
-});
-export const resolve = (request) => {
-    const value = request.providerOptions?.gemini?.thinkingConfig;
-    if (!ProviderShared.isRecord(value))
-        return {};
-    const thinkingConfig = {
-        thinkingBudget: typeof value.thinkingBudget === "number" ? value.thinkingBudget : undefined,
-        includeThoughts: typeof value.includeThoughts === "boolean" ? value.includeThoughts : undefined,
-    };
-    return {
-        thinkingConfig: Object.values(thinkingConfig).some((item) => item !== undefined) ? thinkingConfig : undefined,
-    };
-};
-export * as GeminiOptions from "./gemini-options";

package/dist/providers/anthropic-options.d.ts

@@ -1,24 +0,0 @@
-import type { ProviderOptions } from "../schema";
-export type AnthropicThinkingInput = {
-    readonly type: "adaptive";
-    readonly display?: "summarized" | "omitted";
-} | {
-    readonly type: "disabled";
-} | ({
-    readonly type: "enabled";
-} & ({
-    readonly budgetTokens: number;
-    readonly budget_tokens?: number;
-} | {
-    readonly budgetTokens?: number;
-    readonly budget_tokens: number;
-}));
-export interface AnthropicOptionsInput {
-    readonly [key: string]: unknown;
-    readonly thinking?: AnthropicThinkingInput;
-    readonly effort?: string;
-}
-export type AnthropicProviderOptionsInput = ProviderOptions & {
-    readonly anthropic?: AnthropicOptionsInput;
-};
-export * as AnthropicProviderOptions from "./anthropic-options";

package/dist/providers/anthropic-options.js

@@ -1 +0,0 @@
-export * as AnthropicProviderOptions from "./anthropic-options";

package/dist/providers/gemini-options.d.ts

@@ -1,10 +0,0 @@
-import type { ThinkingConfig } from "../protocols/utils/gemini-options";
-import type { ProviderOptions } from "../schema";
-export interface GeminiOptionsInput {
-    readonly [key: string]: unknown;
-    readonly thinkingConfig?: ThinkingConfig;
-}
-export type GeminiProviderOptionsInput = ProviderOptions & {
-    readonly gemini?: GeminiOptionsInput;
-};
-export * as GeminiProviderOptions from "./gemini-options";

package/dist/providers/gemini-options.js

@@ -1 +0,0 @@
-export * as GeminiProviderOptions from "./gemini-options";