vern-llm 2.3.0 → 2.4.0

package/dist/index.cjs

@@ -95,6 +95,42 @@ function safeIssues(issues) {
 	}
 }
 /**
+* Returns a JSON safe, independent copy of `body`, or a marker string if
+* `body` can't survive `JSON.stringify` (e.g. a circular reference). A
+* request body built from adapter-transformed messages is normally
+* always plain data, but tool call arguments or a caller supplied
+* `cause`-adjacent value could in principle carry a circular reference,
+* so this guards the same way `safeIssues` does rather than assuming it
+* can't happen. Unlike `safeIssues`, this clones rather than returning
+* the same reference: the object backing a request body can still be
+* mutated by adapter code between when a request is dispatched and when
+* an attempt is later recorded as failed (e.g. `fromGemini` sets
+* `request.config` in place), so returning the same reference here could
+* make a stored snapshot silently reflect a later, different state than
+* what was actually sent.
+*/
+function safeBody(body) {
+	if (body === void 0) return void 0;
+	try {
+		return JSON.parse(JSON.stringify(body));
+	} catch {
+		return "[Unserializable: request body contained a circular reference]";
+	}
+}
+const AUTH_HEADER_NAMES = new Set([
+	"authorization",
+	"x-api-key",
+	"x-goog-api-key",
+	"api-key"
+]);
+/** Removes auth headers before a request snapshot is built. Case insensitive on header names. */
+function stripAuthHeaders(headers) {
+	if (headers === void 0) return void 0;
+	const out = {};
+	for (const [key, value] of Object.entries(headers)) if (!AUTH_HEADER_NAMES.has(key.toLowerCase())) out[key] = value;
+	return out;
+}
+/**
 * Depth cap for `safeAttempts`, guarding against a pathological,
 * self referential `attempts` array. `attempts` is a public
 * `LLMErrorOptions` field, so a caller can construct one by hand; this
@@ -110,8 +146,12 @@ const MAX_ATTEMPTS_DEPTH = 20;
 * circular one after the snapshot was created, and `attempts` is a
 * public constructor option, so a caller can hand build a `RetryAttempt`
 * (or a whole `LLMErrorSnapshot`) with a circular `issues` and pass it
-* in directly, never touching `toSnapshot()` at all. Extra fields on an
-* attempt (e.g. `FallbackAttempt`'s `provider`/`model`) are preserved.
+* in directly, never touching `toSnapshot()` at all. The same applies to
+* `request`: its `body` is re-checked through `safeBody`, and its
+* `headers` are re-stripped through `stripAuthHeaders`, so a hand built
+* `RetryAttempt.request` can't smuggle an auth header past `toSnapshot()`
+* either. Extra fields on an attempt (e.g. `FallbackAttempt`'s
+* `provider`/`model`) are preserved.
 */
 function safeAttempts(attempts, depth = 0) {
 	if (attempts === void 0) return void 0;
@@ -122,9 +162,37 @@ function safeAttempts(attempts, depth = 0) {
 			...attempt.error,
 			issues: safeIssues(attempt.error.issues),
 			attempts: safeAttempts(attempt.error.attempts, depth + 1)
+		},
+		request: attempt.request && {
+			...attempt.request,
+			body: safeBody(attempt.request.body),
+			headers: stripAuthHeaders(attempt.request.headers)
 		}
 	}));
 }
+/**
+* Builds a point-in-time, plain data copy of one attempt's outgoing
+* request. Mirrors `LLMError.toSnapshot()`: never thrown or dispatched
+* again, safe to serialize and store. A plain function rather than a
+* method, since unlike `LLMError` a request has no throwable identity or
+* derived state worth wrapping in a class.
+*
+* `startedAt` is optional so existing call sites (and tests) that don't
+* care about exact timing keep working, but a caller that has a real
+* capture time should always pass it: this function may run well after
+* the request was actually dispatched (e.g. `callExecutor` only builds
+* the snapshot once an attempt has failed), so defaulting to `Date.now()`
+* here would record failure-handling time, not request-start time.
+*/
+function toRequestSnapshot(provider, model, body, headers, startedAt = Date.now()) {
+	return {
+		provider,
+		model,
+		body: safeBody(body),
+		headers: stripAuthHeaders(headers),
+		startedAt
+	};
+}
 var LLMError = class extends Error {
 	status;
 	issues;
@@ -1257,6 +1325,41 @@ function codeForStatus(status) {
 	}
 }
 /**
+* Whether a provider's error response actually contains anything a person
+* could act on. Some providers return a non-2xx status with **no body at
+* all** for certain field-validation failures (Mistral's OpenAI-compatible
+* endpoint does this, for example, when a request includes a field the
+* target model doesn't support). SDKs built on top of `openai` render that
+* specific case as a message like `"400 status code (no body)"`.
+*
+* Derived from the object's own `error`/`message` fields directly, rather
+* than from whatever `describeError` rendered, because `describeError`
+* falls back to serializing the *whole* thrown value when neither field is
+* present or meaningful. That fallback is local echo (e.g. just the
+* `status` a caller passed in), not provider diagnostic content, and
+* treating it as "detail" defeats the whole point of this check.
+*/
+const NO_BODY_MESSAGE_PATTERN = /\(no body\)/i;
+function isEmptyObject(value) {
+	return Object.keys(value).length === 0;
+}
+function hasNoDiagnosticDetail(error) {
+	if (error && typeof error === "object") {
+		const { error: errorField, message } = error;
+		if (errorField !== void 0 && errorField !== null) {
+			const isEmptyString = typeof errorField === "string" && errorField.trim().length === 0;
+			const isEmptyStruct = typeof errorField === "object" && isEmptyObject(errorField);
+			if (!isEmptyString && !isEmptyStruct) return false;
+		}
+		if (typeof message === "string") {
+			const trimmed = message.trim();
+			return trimmed.length === 0 || NO_BODY_MESSAGE_PATTERN.test(trimmed);
+		}
+		return true;
+	}
+	return true;
+}
+/**
 * Converts any thrown value into a well-typed LLMError. `attempts`, when
 * given, is the accumulated record of every attempt made before `error`
 * was thrown; it's passed straight into the constructed error's options
@@ -1273,13 +1376,19 @@ function normalizeError(error, signal, attempts) {
 	}
 	const status = extractStatus(error);
 	const retryAfterMs = extractRetryAfterMs(error);
-	if (status !== void 0) return new LLMError("LLM request failed", "api", {
-		status,
-		cause: error,
-		retryAfterMs,
-		code: codeForStatus(status),
-		attempts
-	});
+	if (status !== void 0) {
+		const description = describeError(error);
+		const code = codeForStatus(status);
+		const isRequestValidationStatus = code === void 0;
+		const message = hasNoDiagnosticDetail(error) ? isRequestValidationStatus ? `LLM request failed with status ${status} and no error detail from the provider. This usually means a field or value in the request isn't supported by the specific model (for example, a reasoning/thinking parameter the model doesn't accept), rather than a transport or auth problem.` : `LLM request failed with status ${status} and no error detail from the provider.` : `LLM request failed: ${description}`;
+		return new LLMError(message, "api", {
+			status,
+			cause: error,
+			retryAfterMs,
+			code,
+			attempts
+		});
+	}
 	if (isNetworkError(error)) return new LLMError("LLM request failed", "network", {
 		cause: error,
 		retryAfterMs,
@@ -1352,6 +1461,13 @@ function parseWireToolCalls(wireToolCalls) {
 //#endregion
 //#region src/internal/execution/requestBuilder.ts
 /**
+* Serializes `ConversationTurn` assistant content for the wire. Strings
+* pass through unchanged. Parsed JSON values are `JSON.stringify`'d.
+*/
+function serializeAssistantContent(content) {
+	return typeof content === "string" ? content : JSON.stringify(content);
+}
+/**
 * Builds the wire request object for one call, applying per-instance
 * defaults (model, max tokens, temperature) and per-call overrides.
 * Owns every check that depends only on the caller's own input shape, not
@@ -1369,15 +1485,23 @@ var RequestBuilder = class {
 	model;
 	defaultMaxTokens;
 	defaultTemperature;
+	defaultReasoningEffort;
+	defaultBudgetTokens;
+	supportsJsonObjectMode;
 	constructor(options) {
 		this.model = options.model;
 		this.defaultMaxTokens = options.defaultMaxTokens;
 		this.defaultTemperature = options.defaultTemperature;
+		this.defaultReasoningEffort = options.defaultReasoningEffort;
+		this.defaultBudgetTokens = options.defaultBudgetTokens;
+		this.supportsJsonObjectMode = options.supportsJsonObjectMode;
 	}
 	/** Applies per-call defaults and shapes params into the client's request object. */
 	build(params) {
-		const { systemPrompt, userContent, history = [], maxTokens = this.defaultMaxTokens, model = this.model, reasoningEffort, jsonSchema, tools, toolChoice } = params;
+		const { systemPrompt, userContent, history = [], maxTokens = this.defaultMaxTokens, model = this.model, jsonSchema, tools, toolChoice } = params;
 		const temperature = params.temperature === void 0 ? this.defaultTemperature : params.temperature;
+		const reasoningEffort = params.reasoningEffort === void 0 ? this.defaultReasoningEffort : params.reasoningEffort;
+		const budgetTokens = params.budgetTokens === void 0 ? this.defaultBudgetTokens : params.budgetTokens;
 		if (tools && tools.length === 0) throw new LLMError("`tools` was an empty array. This is almost always a bug (e.g. a filtered tool list that ended up empty). An empty `tools` array still switches on tool-call mode (response shape, jsonMode default, wire format) with nothing for the model to call. Omit `tools` entirely for a normal call, or make sure the array is non-empty.", "invalid_params");
 		if (tools) {
 			const seen = new Set();
@@ -1399,8 +1523,12 @@ var RequestBuilder = class {
 				available: tools.map((t) => t.name)
 			}
 		});
-		const jsonMode = params.jsonMode ?? (tools ? false : true);
-		const useJson = jsonMode || Boolean(jsonSchema);
+		const jsonModeExplicit = params.jsonMode;
+		const jsonMode = jsonModeExplicit ?? (tools ? false : true);
+		if (!this.supportsJsonObjectMode && !jsonSchema && jsonModeExplicit === true) throw new LLMError("jsonMode: true was set explicitly, but this client does not support `response_format: \"json_object\"` (see LLMClient.supportsJsonObjectMode). Neither Anthropic nor Bedrock has a field that mechanically guarantees JSON output for this mode. Use `jsonSchema` instead, which maps to a real constraint on both.", "invalid_params");
+		if (!this.supportsJsonObjectMode && !jsonSchema && jsonModeExplicit === void 0 && params.schema) throw new LLMError("`schema` was provided, which requires JSON output to validate against, but this client does not support `response_format: \"json_object\"` (see LLMClient.supportsJsonObjectMode) and no `jsonSchema` was set. Neither Anthropic nor Bedrock has a field that mechanically guarantees JSON output without one. Use `jsonSchema` instead, which maps to a real constraint on both and still runs `schema` against its parsed result.", "invalid_params");
+		const jsonModeEffective = !this.supportsJsonObjectMode && !jsonSchema && jsonModeExplicit === void 0 ? false : jsonMode;
+		const useJson = jsonModeEffective || Boolean(jsonSchema);
 		if (params.schema && !useJson) throw new LLMError("schema was provided but jsonMode: false disables JSON parsing, so nothing would validate it. Remove jsonMode: false, set jsonSchema, or remove schema.", "invalid_params");
 		const responseFormat = this.buildResponseFormat(jsonSchema, useJson);
 		this.validateHistory(history);
@@ -1410,6 +1538,7 @@ var RequestBuilder = class {
 			max_tokens: maxTokens,
 			...responseFormat ? { response_format: responseFormat } : {},
 			...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
+			...budgetTokens !== void 0 && budgetTokens !== null ? { budget_tokens: budgetTokens } : {},
 			...tools ? { tools: toWireTools(tools) } : {},
 			...tools ? { tool_choice: this.buildWireToolChoice(toolChoice) } : {},
 			messages: [
@@ -1505,9 +1634,13 @@ var RequestBuilder = class {
 		}));
 		if (turn.role === "assistant" && turn.toolCalls?.length) return [{
 			role: "assistant",
-			...turn.content ? { content: turn.content } : {},
+			...turn.content !== void 0 ? { content: serializeAssistantContent(turn.content) } : {},
 			tool_calls: toWireToolCalls(turn.toolCalls)
 		}];
+		if (turn.role === "assistant") return [{
+			role: "assistant",
+			content: serializeAssistantContent(turn.content === void 0 ? "" : turn.content)
+		}];
 		return [{
 			role: turn.role,
 			content: turn.content ?? ""
@@ -1641,10 +1774,12 @@ function buildStreamResult(iterator, first, options) {
 						complete: wireChunk.complete
 					});
 				} else if (wireChunk.type === "usage") {
+					const reasoningTokens = wireChunk.usage.completion_tokens_details?.reasoning_tokens;
 					usage = {
 						promptTokens: wireChunk.usage.prompt_tokens ?? 0,
 						completionTokens: wireChunk.usage.completion_tokens ?? 0,
 						totalTokens: wireChunk.usage.total_tokens ?? 0,
+						...reasoningTokens !== void 0 ? { reasoningTokens } : {},
 						requestId,
 						model,
 						provider: providerName,
@@ -1698,6 +1833,16 @@ function buildStreamResult(iterator, first, options) {
 //#endregion
 //#region src/internal/execution/callExecutor.ts
 /**
+* Identity function with its own parameter, used only to sidestep a TS
+* quirk: a `let` reassigned solely inside a nested closure (like
+* `retryWithBackoff`'s `onRequest`) gets narrowed to `undefined` at the
+* point it was last synchronously assigned, which would otherwise make
+* `lastRequestForAttempt` read as `never` at the point it's used below.
+*/
+function passThroughRequestSnapshot(snapshot) {
+	return snapshot;
+}
+/**
 * Everything one provider target needs to attempt a call: request
 * building, retry with backoff, the per-target breaker, the per-target
 * limiter. Never exported publicly. `VernLLM` holds one per target and
@@ -1740,7 +1885,10 @@ var CallExecutor = class {
 		this.requestBuilder = new RequestBuilder({
 			model,
 			defaultMaxTokens: options.defaultMaxTokens,
-			defaultTemperature: options.defaultTemperature
+			defaultTemperature: options.defaultTemperature,
+			defaultReasoningEffort: options.defaultReasoningEffort,
+			defaultBudgetTokens: options.defaultBudgetTokens,
+			supportsJsonObjectMode: client.supportsJsonObjectMode ?? true
 		});
 	}
 	getCircuitState(model) {
@@ -1781,7 +1929,7 @@ var CallExecutor = class {
 		const model = params.model ?? this.model;
 		const attempts = [];
 		try {
-			return await this.retryWithBackoff((attempt) => this.executeCall(params, requestId, attempt), requestId, model, params.signal, onAttempt, attempts);
+			return await this.retryWithBackoff((attempt, onRequest) => this.executeCall(params, requestId, attempt, onRequest), requestId, model, params.signal, onAttempt, attempts);
 		} catch (error) {
 			const normalized = normalizeError(error, params.signal, attempts.length > 0 ? attempts : void 0);
 			if (this.countsTowardBreaker(normalized)) this.breaker?.recordFailure(model);
@@ -1794,7 +1942,7 @@ var CallExecutor = class {
 		const model = params.model ?? this.model;
 		const attempts = [];
 		try {
-			return await this.retryWithBackoff((attempt) => this.executeStreamCall(params, requestId, attempt), requestId, model, params.signal, onAttempt, attempts);
+			return await this.retryWithBackoff((attempt, onRequest) => this.executeStreamCall(params, requestId, attempt, onRequest), requestId, model, params.signal, onAttempt, attempts);
 		} catch (error) {
 			const normalized = normalizeError(error, params.signal, attempts.length > 0 ? attempts : void 0);
 			if (this.countsTowardBreaker(normalized)) this.breaker?.recordFailure(model);
@@ -1809,8 +1957,9 @@ var CallExecutor = class {
 	* set. Throws on an empty response (no text and no tool_calls) so the
 	* retry loop treats it like any other transient failure.
 	*/
-	async executeCall(params, requestId, attempt) {
+	async executeCall(params, requestId, attempt, onRequest) {
 		const { useJson, model, request } = this.requestBuilder.build(params);
+		onRequest?.(toRequestSnapshot(this.providerName, model, request, void 0, Date.now()));
 		let release;
 		if (this.limiter) {
 			const acquired = await this.limiter.acquire(this.limiter.estimate(request), params.signal);
@@ -1918,8 +2067,9 @@ var CallExecutor = class {
 	* not on the first chunk arriving, so a connection that opens but then
 	* dies mid-stream isn't masked as a success (see `buildStreamResult`).
 	*/
-	async executeStreamCall(params, requestId, attempt) {
+	async executeStreamCall(params, requestId, attempt, onRequest) {
 		const { useJson, model, request } = this.requestBuilder.build(params);
+		onRequest?.(toRequestSnapshot(this.providerName, model, request, void 0, Date.now()));
 		const completions = this.client.chat.completions;
 		if (!completions.createStream) throw new LLMError("stream: true requires a client/adapter with createStream", "invalid_params", {
 			code: "unsupported_capability",
@@ -2039,18 +2189,25 @@ var CallExecutor = class {
 	*/
 	async retryWithBackoff(fn, requestId, model, signal, onAttempt, attempts) {
 		let lastError;
-		for (let attempt = 0; attempt <= this.maxRetries; attempt++) try {
-			if (attempt > 0) await this.recoverDelay(requestId, model, attempt, lastError, signal);
-			onAttempt?.();
-			return await fn(attempt);
-		} catch (error) {
-			lastError = error;
-			const willRetry = attempt < this.maxRetries && this.shouldRetry(error, signal);
-			if (!willRetry) break;
-			attempts?.push({
-				index: attempt,
-				error: normalizeError(error, signal).toSnapshot()
-			});
+		let lastRequestForAttempt;
+		for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+			lastRequestForAttempt = void 0;
+			try {
+				if (attempt > 0) await this.recoverDelay(requestId, model, attempt, lastError, signal);
+				onAttempt?.();
+				return await fn(attempt, (req) => {
+					lastRequestForAttempt = req;
+				});
+			} catch (error) {
+				lastError = error;
+				const willRetry = attempt < this.maxRetries && this.shouldRetry(error, signal);
+				if (!willRetry) break;
+				attempts?.push({
+					index: attempt,
+					error: normalizeError(error, signal).toSnapshot(),
+					request: passThroughRequestSnapshot(lastRequestForAttempt)
+				});
+			}
 		}
 		throw lastError;
 	}
@@ -2062,10 +2219,12 @@ var CallExecutor = class {
 	*/
 	extractUsage(response, requestId, model) {
 		if (!response.usage) return void 0;
+		const reasoningTokens = response.usage.completion_tokens_details?.reasoning_tokens;
 		return {
 			promptTokens: response.usage.prompt_tokens ?? 0,
 			completionTokens: response.usage.completion_tokens ?? 0,
 			totalTokens: response.usage.total_tokens ?? 0,
+			...reasoningTokens !== void 0 ? { reasoningTokens } : {},
 			requestId,
 			model,
 			provider: this.providerName,
@@ -2489,7 +2648,7 @@ var RateLimiter = class {
 //#endregion
 //#region src/vernLLM.ts
 /**
-* A resilient layer around an LLM chat completions client. This is VernLLM!
+* A LLM call framework for resilience, observability and control. This is VernLLM!
 *
 * Adds retry with backoff and jitter, per-attempt timeouts, an optional
 * circuit breaker, JSON parsing with optional schema validation, usage
@@ -2529,6 +2688,8 @@ var VernLLM = class {
 		this.fallbackOn = options.fallbackOn ?? defaultFallbackOn;
 		this.reportEvent = makeEventReporter(options.onEvent, this.logger);
 		const primaryDefaultTemperature = options.defaultTemperature === void 0 ? .2 : options.defaultTemperature;
+		const primaryDefaultReasoningEffort = options.defaultReasoningEffort;
+		const primaryDefaultBudgetTokens = options.defaultBudgetTokens;
 		const primaryTarget = {
 			client: options.client,
 			model: options.model,
@@ -2539,6 +2700,8 @@ var VernLLM = class {
 			baseDelayMs: options.baseDelayMs,
 			defaultMaxTokens: options.defaultMaxTokens,
 			defaultTemperature: primaryDefaultTemperature,
+			defaultReasoningEffort: primaryDefaultReasoningEffort,
+			defaultBudgetTokens: primaryDefaultBudgetTokens,
 			nonRetryableStatus: options.nonRetryableStatus,
 			circuitBreaker: options.circuitBreaker,
 			rateLimit: options.rateLimit
@@ -2556,6 +2719,8 @@ var VernLLM = class {
 				baseDelayMs: target.baseDelayMs ?? options.baseDelayMs ?? 500,
 				defaultMaxTokens: target.defaultMaxTokens ?? options.defaultMaxTokens ?? 1e3,
 				defaultTemperature: target.defaultTemperature === void 0 ? primaryDefaultTemperature : target.defaultTemperature,
+				defaultReasoningEffort: target.defaultReasoningEffort === void 0 ? primaryDefaultReasoningEffort : target.defaultReasoningEffort,
+				defaultBudgetTokens: target.defaultBudgetTokens === void 0 ? primaryDefaultBudgetTokens : target.defaultBudgetTokens,
 				nonRetryableStatus: target.nonRetryableStatus ?? options.nonRetryableStatus ?? [
 					400,
 					401,
@@ -2757,6 +2922,45 @@ var VernLLM = class {
 		if (model !== void 0 && !isolateByModel) this.logger.warn(`[VernLLM] ${caller}: \`model: '${model}'\` has no effect here. This target's circuitBreaker doesn't have isolateByModel on, so it only tracks one shared circuit regardless of \`model\`. Omit \`model\`, or set \`circuitBreaker.isolateByModel: true\` on this target if per-model tracking is what you want.`);
 	}
 };
+/**
+* Identity function preserving `params`'s own precise type, unlike a `:
+* CallParams<T>` annotation, which would widen `tools` away and break the
+* `ConditionalToolCallParams<T>` overload for `tools: someCondition ?
+* [tool] : undefined`. Use it when you need `call()` params in a named,
+* reusable variable; skip it when you can pass the object inline.
+*
+* ```ts
+* const params = defineCallParams({
+*   userContent: 'What is the weather?',
+*   tools: someCondition ? [weatherTool] : undefined,
+* });
+* const result = await llm.call(params);
+* // result: unknown | CallWithToolsResult<unknown>, same as inline
+* ```
+*
+* `T` isn't a parameter here; pin it via `llm.call<T>(params)` as usual.
+* `defineCachedCallParams` is the `cachedCall()` counterpart.
+*/
+function defineCallParams(params) {
+	return params;
+}
+/**
+* The `cachedCall()` counterpart to `defineCallParams`: preserves the
+* whole `{ cacheKey, ttl, call }` object, `call.tools` included, in one
+* named variable.
+*
+* ```ts
+* const params = defineCachedCallParams({
+*   cacheKey: 'weather-ny',
+*   ttl: 60,
+*   call: { userContent: 'What is the weather?', tools: someCondition ? [weatherTool] : undefined },
+* });
+* const result = await llm.cachedCall(params);
+* ```
+*/
+function defineCachedCallParams(params) {
+	return params;
+}
 
 //#endregion
 //#region src/adapters/internal/sse.ts
@@ -2897,6 +3101,275 @@ function supportsNativeStructuredOutput(model, override) {
 	return Array.isArray(override) ? override.includes(model) : override(model);
 }
 
+//#endregion
+//#region src/adapters/internal/reasoningBudget.utils.ts
+const DEFAULT_EFFORT_TOKENS = {
+	minimal: 1024,
+	low: 4096,
+	medium: 16e3,
+	high: 32e3
+};
+/**
+* Merges a caller-supplied partial override over `DEFAULT_EFFORT_TOKENS`.
+* Called once per adapter instance (not per request), so a per-instance
+* override only needs to specify the tiers it actually wants to change.
+*
+* Throws `LLMError('invalid_params')` if the override doesn't keep the
+* tiers in strictly ascending order (`minimal < low < medium < high`).
+* `budgetTokensToEffort` buckets by walking the tiers low to high and
+* returning on the first one a value is `<=`, so an unordered table (e.g.
+* `low` above `medium`) wouldn't just produce a "wrong" bucket, it would
+* make some tiers unreachable outright, silently, with no signal to the
+* caller that their override doesn't do what they think it does.
+*/
+function resolveEffortTokenTable(override) {
+	if (!override) return DEFAULT_EFFORT_TOKENS;
+	const table = {
+		...DEFAULT_EFFORT_TOKENS,
+		...override
+	};
+	if (!(table.minimal < table.low && table.low < table.medium && table.medium < table.high)) throw new LLMError(`reasoningEffortTokens must keep tiers in strictly ascending order (minimal < low < medium < high), got ${JSON.stringify(table)}. An out-of-order override doesn't just misrank tiers, it can make some of them unreachable.`, "invalid_params");
+	return table;
+}
+/** Converts a `reasoningEffort` tier into the nearest `budgetTokens` value. */
+function effortToBudgetTokens(effort, table = DEFAULT_EFFORT_TOKENS) {
+	return table[effort];
+}
+/**
+* Converts a raw `budgetTokens` value into the nearest `reasoningEffort`
+* tier, for providers that only understand tiers. Buckets by the same
+* `table` `effortToBudgetTokens` produces its values from, so the two
+* functions agree with each other at the boundary values, as long as the
+* same (possibly overridden) table is passed to both. A value strictly
+* between two tiers (e.g. 4097, one above the default `low`) rounds up to
+* the next tier it's still `<=`, i.e. `medium` here, not down to `low`.
+*/
+function budgetTokensToEffort(budgetTokens, table = DEFAULT_EFFORT_TOKENS) {
+	if (budgetTokens <= table.minimal) return "minimal";
+	if (budgetTokens <= table.low) return "low";
+	if (budgetTokens <= table.medium) return "medium";
+	return "high";
+}
+/**
+* Parses an Opus model id's generation and minor version, e.g.
+* `"claude-opus-4-7-20260101"` -> `[4, 7]`, `"anthropic.claude-opus-5-x"` ->
+* `[5, 0]`. Not anchored, so it matches equally inside a bare Anthropic id
+* or a Bedrock id carrying a provider prefix. Returns `null` for a
+* non-Opus model id.
+*/
+/**
+* Parses an Opus model id's generation and minor version, e.g.
+* `"claude-opus-4-7-20260101"` -> `[4, 7]`, `"anthropic.claude-opus-5-x"` ->
+* `[5, 0]`. Not anchored, so it matches equally inside a bare Anthropic id
+* or a Bedrock id carrying a provider prefix. Returns `null` for a
+* non-Opus model id.
+*
+* Anthropic model ids sometimes carry a trailing snapshot date instead of
+* (or in addition to) an explicit minor version, e.g. the real, still-
+* supported base `"claude-opus-4-20250514"` (no `.7`-style minor at all,
+* just a date suffix directly after the major version). Read naively,
+* `20250514` looks like a minor version far above any real threshold and
+* would misclassify this pre-4.6 model as adaptive-only. Snapshot dates
+* are always 8 digits (`YYYYMMDD`); a real minor version never is, so an
+* 8+ digit second segment is treated as a date, not a minor version.
+*/
+function parseOpusVersion(model) {
+	const match = /opus-(\d+)(?:-(\d+))?/.exec(model);
+	if (!match) return null;
+	const minorStr = match[2];
+	const minor = minorStr === void 0 || minorStr.length >= 8 ? 0 : Number(minorStr);
+	return [Number(match[1]), minor];
+}
+/**
+* Default rule for whether `model` only supports adaptive thinking
+* (`thinking: { type: 'adaptive' }`) and returns a 400 for manual,
+* budget-based thinking (`thinking: { type: 'enabled', budget_tokens }`):
+* Claude Opus 4.7 and later (matched as a version threshold, so 4.8, 4.9,
+* 5, and every future Opus point release are covered automatically,
+* without a new list entry per release), and every Claude 5 tier model
+* outside the Opus family (Sonnet 5, Fable 5, Mythos 5, Mythos Preview).
+* `mythos` alone is enough to catch both Mythos names without listing
+* each separately.
+*
+* Necessarily best-effort: a new model family with its own name (not
+* `opus-*`, not `sonnet-5`/`fable-5`/`mythos-*`) still needs a code
+* update here, or a caller-supplied `adaptiveOnlyModels` override (see
+* `isAdaptiveOnlyModel`) covering it in the meantime.
+*/
+function isDefaultAdaptiveOnly(model) {
+	const opusVersion = parseOpusVersion(model);
+	if (opusVersion) {
+		const [major, minor] = opusVersion;
+		return major > 4 || major === 4 && minor >= 7;
+	}
+	return [
+		"sonnet-5",
+		"fable-5",
+		"mythos"
+	].some((s) => model.includes(s));
+}
+/**
+* Whether `model` is adaptive-only, per the built-in rule above, or per a
+* caller-supplied `adaptiveOnlyModels` override. The override is
+* additive, not a replacement: it can mark an *additional* model as
+* adaptive-only (useful for a model family this package doesn't know
+* about yet), but it can't un-mark one the built-in rule already caught,
+* since a caller correcting a false negative is the only direction that
+* needs covering, a false positive here would mean this package is
+* simply wrong and needs its own fix, not a per-caller workaround.
+*/
+function isAdaptiveOnlyModel(model, override) {
+	if (isDefaultAdaptiveOnly(model)) return true;
+	if (!override) return false;
+	return Array.isArray(override) ? override.includes(model) : override(model);
+}
+/** Whether `model` is known to support manual, budget-based thinking. */
+function supportsManualThinkingBudget(model, override) {
+	return !isAdaptiveOnlyModel(model, override);
+}
+/**
+* Anthropic (and Claude models on Bedrock) require `budget_tokens` to be
+* at least 1024 and strictly less than `max_tokens`, since the thinking
+* budget and the reply share the same `max_tokens` ceiling. VernLLM's own
+* default `maxTokens` is 1000 (see `RequestBuilder`'s `defaultMaxTokens`),
+* below the 1024 floor, so the *default* `minimal` tier (1024 tokens) is
+* silently invalid against the *default* `max_tokens` unless a caller
+* happens to raise one or the other. Checked here, once, right before a
+* `thinking` block would be built, rather than left for Anthropic's own
+* 400 to explain after a real network round trip.
+*/
+function assertValidClaudeBudgetTokens(budgetTokens, maxTokens) {
+	if (budgetTokens < 1024) throw new LLMError(`budgetTokens (${budgetTokens}) is below Anthropic's minimum of 1024. Raise budgetTokens, or use a reasoningEffort tier of 'low' or above with the default conversion table.`, "invalid_params");
+	if (budgetTokens >= maxTokens) throw new LLMError(`budgetTokens (${budgetTokens}) must be less than maxTokens (${maxTokens}); the thinking budget and the reply share the same max_tokens ceiling on Anthropic. Raise maxTokens, or lower budgetTokens/reasoningEffort.`, "invalid_params");
+}
+/**
+* Anthropic rejects any form of `thinking` (manual `budget_tokens` or
+* adaptive) combined with a `tool_choice` that forces tool use, a forced
+* single tool or "must call some tool", with a 400: `"Thinking may not be
+* enabled when tool_choice forces tool use."` Auto/none (or no tools at
+* all) are unaffected, thinking only conflicts with a choice that removes
+* the model's ability to just reply with text. This is a Claude-model
+* constraint, not specific to the Anthropic API's own wire shape, so it
+* applies identically to Claude models called through Bedrock's Converse
+* API, which forwards `thinking` under `additionalModelRequestFields` but
+* is still talking to the same underlying model.
+*
+* This combination can arise two ways: a caller explicitly sets both
+* `budgetTokens`/`reasoningEffort` and a forced `toolChoice`, or, more
+* subtly (Anthropic adapter only), a caller sets `jsonSchema` on a model
+* without native structured output support, which silently forces a
+* single synthetic tool call to emulate it, with no `tool_choice` of the
+* caller's own in sight. Both end up resolving to a forced tool choice by
+* the time each adapter calls this, so checking the adapter's own
+* already-resolved choice (rather than the caller's raw
+* `params.tool_choice`) catches both, right before a `thinking` block
+* would be built, rather than left for Anthropic's own 400 to explain
+* after a real network round trip.
+*
+* Takes a plain description of the forced choice rather than either
+* adapter's own wire shape (Anthropic SDK's `{ type: 'tool' | 'any', ... }`
+* vs Converse's `{ tool: {...} } | { any: {} }`), so both adapters can
+* share one check without either shape leaking into this file. Pass
+* `undefined` when the resolved choice is `auto`/`none`/unset, forcing
+* nothing.
+*/
+function assertNoForcedToolChoiceWithThinking(forcedChoiceDescription) {
+	if (!forcedChoiceDescription) return;
+	throw new LLMError(`budgetTokens/reasoningEffort was set alongside ${forcedChoiceDescription}. Anthropic rejects thinking combined with a tool_choice that forces tool use, the model has to be able to reply with plain text for thinking to run. Use toolChoice: 'auto' (or omit toolChoice) for this call, or drop budgetTokens/reasoningEffort for it.`, "invalid_params");
+}
+/**
+* Maps VernLLM's four-tier `reasoningEffort` onto Anthropic's five-tier
+* adaptive effort. `xhigh` and `max` have no VernLLM-side equivalent and
+* are unreachable through this mapping; a caller who wants either has to
+* target Anthropic/Bedrock-specific behavior already, so there's no gap
+* the shared `CallParams` surface needs to cover for a first pass.
+*/
+function toClaudeAdaptiveEffort(effort) {
+	return effort === "minimal" ? "low" : effort;
+}
+/** Converts VernLLM's `reasoningEffort` directly into Gemini's `ThinkingLevel` enum value. */
+function toGeminiThinkingLevel(effort, model) {
+	return clampGeminiThinkingLevel(model, effort.toUpperCase());
+}
+/**
+* Parses a Gemini model id's minor version, e.g. `"gemini-3.1-pro"` -> `1`,
+* `"gemini-3-pro"` -> `0` (no explicit minor). Only meaningful alongside
+* `parseGeminiMajorVersion`.
+*/
+function parseGeminiMinorVersion(model) {
+	const match = /gemini-\d+\.(\d+)/.exec(model);
+	return match ? Number(match[1]) : 0;
+}
+/**
+* Some Gemini 3 "Pro" tier models accept a narrower set of `thinkingLevel`
+* values than VernLLM's four tiers map onto, confirmed against real API
+* 400s and Google's own migration guidance, not assumed:
+* - Gemini 3 Pro (major 3, minor 0, e.g. `"gemini-3-pro-preview"`): only
+*   `LOW` and `HIGH`; `MEDIUM` returns a 400 ("Thinking level MEDIUM is
+*   not supported for this model").
+* - Gemini 3.1 Pro (major 3, minor >= 1): `LOW`/`MEDIUM`/`HIGH`, no
+*   `MINIMAL`, Google's own docs point users toward a Flash-tier model
+*   instead for the lowest setting.
+* - Every Flash-tier Gemini 3+ model accepts the full four levels, no
+*   clamping needed, matched by this function simply not applying to
+*   anything without `"pro"` in the model id.
+*
+* Clamped automatically rather than left to error, since `reasoningEffort`
+* is a per-call value, a caller hitting this isn't misconfiguring an
+* instance once, they're getting an intermittent-looking failure on
+* whichever specific call happened to pick an unsupported tier. Necessarily
+* best-effort: a future Pro-tier release could add back a level this rule
+* still clamps, or clamp one this rule doesn't yet know to touch.
+*/
+function clampGeminiThinkingLevel(model, level) {
+	if (!model.includes("pro")) return level;
+	const major = parseGeminiMajorVersion(model);
+	if (major === null || major < 3) return level;
+	const minor = parseGeminiMinorVersion(model);
+	if (minor === 0) return level === "HIGH" ? "HIGH" : "LOW";
+	return level === "MINIMAL" ? "LOW" : level;
+}
+/**
+* Parses a Gemini model id's major generation number, e.g.
+* `"gemini-3.1-flash-lite"` -> `3`, `"gemini-2.5-flash"` -> `2`. Not
+* anchored, so a Vertex-prefixed or otherwise decorated id still matches.
+* Returns `null` for a non-Gemini model id.
+*/
+function parseGeminiMajorVersion(model) {
+	const match = /gemini-(\d+)/.exec(model);
+	return match ? Number(match[1]) : null;
+}
+/**
+* Default rule for whether `model` uses `thinkingLevel` instead of
+* `thinkingBudget`: every Gemini 3 series model and later, matched as a
+* version threshold so 3.1, 3.5, 3.6, and every future Gemini 3.x or
+* later release are covered automatically, without a new entry per
+* release, same reasoning as `isDefaultAdaptiveOnly`'s Opus threshold.
+* Gemini 2.5 and earlier still use `thinkingBudget`.
+*
+* `thinkingBudget` is still *accepted* on Gemini 3 for backward
+* compatibility, per Google's own docs, but "may result in unexpected
+* performance" there, so this rule switches VernLLM's own default
+* behavior over rather than leaving it on the old field indefinitely.
+*/
+function isDefaultThinkingLevelModel(model) {
+	const major = parseGeminiMajorVersion(model);
+	return major !== null && major >= 3;
+}
+/**
+* Whether `model` uses `thinkingLevel`, per the built-in version
+* threshold above, or per a caller-supplied `thinkingLevelModels`
+* override. Additive, not a replacement, same reasoning as
+* `isAdaptiveOnlyModel`: an override can mark an *additional* model as
+* using `thinkingLevel` (a model family this package doesn't recognize
+* yet), it can't un-mark one the built-in threshold already caught.
+*/
+function usesGeminiThinkingLevel(model, override) {
+	if (isDefaultThinkingLevelModel(model)) return true;
+	if (!override) return false;
+	return Array.isArray(override) ? override.includes(model) : override(model);
+}
+
 //#endregion
 //#region src/adapters/anthropic.ts
 /**
@@ -2981,7 +3454,7 @@ function buildAnthropicTools(tools, toolChoiceParam) {
 * `params.tools` are left for the normal, non-forced tool-call handling
 * both `create` and `createStream` already do when `toolName` is unset.
 */
-function buildAnthropicRequestBody(params, nativeStructuredOutputModels) {
+function buildAnthropicRequestBody(params, nativeStructuredOutputModels, effortTokenTable, adaptiveOnlyModels) {
 	const systemMessage = params.messages.find((m) => m.role === "system");
 	const conversationMessages = params.messages.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "tool");
 	const jsonSchema = params.response_format?.type === "json_schema" ? params.response_format.json_schema : void 0;
@@ -2989,8 +3462,8 @@ function buildAnthropicRequestBody(params, nativeStructuredOutputModels) {
 	if (jsonSchema && !schemaName) throw new LLMError("json_schema.name must not be empty.", "validation");
 	const isNative = Boolean(jsonSchema) && supportsNativeStructuredOutput(params.model, nativeStructuredOutputModels);
 	if (jsonSchema && params.tools?.length && !isNative) throw new LLMError(`Anthropic model "${params.model}" is not covered by nativeStructuredOutputModels, so \`jsonSchema\` is emulated as a forced single tool call there, which collides with the \`tools\` you also provided. Either drop \`tools\` or \`jsonSchema\` for this call, or pass this model in fromAnthropic's \`nativeStructuredOutputModels\` option once you've confirmed it supports Anthropic's \`output_config.format\`.`, "validation");
+	if (params.response_format?.type === "json_object") throw new LLMError("response_format: \"json_object\" is not supported on Anthropic. Unlike OpenAI, Anthropic has no API-level field that mechanically guarantees valid JSON output for this mode, so it used to be emulated by injecting a \"respond with JSON only\" instruction into the system prompt, a guarantee this adapter can no longer make. Use `jsonSchema` instead, which maps to a real API-level constraint (Anthropic's native output_config.format on covered models, or a forced single tool call otherwise).", "validation");
 	let toolName;
-	let jsonInstruction;
 	let outputFormat;
 	let tools;
 	let toolChoice;
@@ -3013,20 +3486,42 @@ function buildAnthropicRequestBody(params, nativeStructuredOutputModels) {
 			type: "tool",
 			name: toolName
 		};
-	} else if (params.response_format?.type === "json_object") jsonInstruction = "Respond with valid JSON only, no prose or markdown fences.";
+	}
 	if (!jsonSchema && params.tools?.length) ({tools, toolChoice} = buildAnthropicTools(params.tools, params.tool_choice));
-	const system = [systemMessage?.content, jsonInstruction].filter(Boolean).join("\n\n");
+	let thinking;
+	let effort;
+	if (params.budget_tokens !== void 0 || params.reasoning_effort !== void 0) {
+		assertNoForcedToolChoiceWithThinking(toolChoice?.type === "tool" ? `toolChoice forcing the "${toolChoice.name}" tool` : toolChoice?.type === "any" ? "toolChoice: 'required' (Anthropic's \"any\" tool_choice)" : void 0);
+		if (supportsManualThinkingBudget(params.model, adaptiveOnlyModels)) {
+			const budgetTokens = params.budget_tokens ?? effortToBudgetTokens(params.reasoning_effort, effortTokenTable);
+			assertValidClaudeBudgetTokens(budgetTokens, params.max_tokens);
+			thinking = {
+				type: "enabled",
+				budget_tokens: budgetTokens
+			};
+		} else {
+			const effortTier = params.reasoning_effort ?? budgetTokensToEffort(params.budget_tokens, effortTokenTable);
+			thinking = { type: "adaptive" };
+			effort = toClaudeAdaptiveEffort(effortTier);
+		}
+	}
+	const system = systemMessage?.content;
+	const temperature = thinking ? void 0 : params.temperature;
 	const body = {
 		model: params.model,
 		max_tokens: params.max_tokens,
-		...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+		...temperature !== void 0 ? { temperature } : {},
 		system: system || void 0,
 		messages: mergeConsecutiveToolResults$1(conversationMessages.map((m) => toAnthropicMessage(m))),
 		...tools ? {
 			tools,
 			tool_choice: toolChoice
 		} : {},
-		...outputFormat ? { output_config: { format: outputFormat } } : {}
+		...outputFormat || effort ? { output_config: {
+			...outputFormat ? { format: outputFormat } : {},
+			...effort ? { effort } : {}
+		} } : {},
+		...thinking ? { thinking } : {}
 	};
 	return {
 		body,
@@ -3055,103 +3550,113 @@ function buildAnthropicRequestBody(params, nativeStructuredOutputModels) {
 * schema matching applies only when `strict: true` is forwarded and
 * supported.
 *
-* `response_format: json_object` (no schema to build a tool from) falls
-* back to a system-prompt instruction, since there's nothing to constrain
-* generation against. Unlike `jsonSchema`, this combines with real `tools`
-* freely on every model: it's a prompt nudge, not a request field, so
-* there's nothing for it to collide with.
+* `response_format: json_object` throws `LLMError('validation')`. Anthropic
+* has no API-level field that mechanically guarantees JSON output the way
+* OpenAI's `json_object` mode does; the only way to emulate it was a
+* system-prompt instruction with no actual enforcement behind it, a
+* guarantee this adapter no longer pretends to make. Use `jsonSchema`
+* instead, which maps to a real constraint either way (native
+* `output_config.format` or a forced tool call).
 */
 function fromAnthropic(anthropicClient, options) {
 	const nativeStructuredOutputModels = options?.nativeStructuredOutputModels;
+	const effortTokenTable = resolveEffortTokenTable(options?.reasoningEffortTokens);
+	const adaptiveOnlyModels = options?.adaptiveOnlyModels;
 	const rawMessagesCreate = anthropicClient.messages.create.bind(anthropicClient.messages);
-	return { chat: { completions: {
-		async create(params, options$1) {
-			const { body, toolName } = buildAnthropicRequestBody(params, nativeStructuredOutputModels);
-			const response = await anthropicClient.messages.create(body, options$1);
-			let text;
-			let wireToolCalls;
-			if (toolName) {
-				const toolUse = response.content.find((block) => block.type === "tool_use" && block.name === toolName);
-				if (!toolUse) throw new LLMError(`Anthropic did not return the required structured output tool "${toolName}".`, "validation");
-				if (!toolUse.input || typeof toolUse.input !== "object" || Array.isArray(toolUse.input)) throw new LLMError(`Anthropic returned invalid structured output for tool "${toolName}". Expected an object.`, "validation");
-				text = JSON.stringify(toolUse.input);
-			} else {
-				text = response.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
-				const toolUses = response.content.filter((block) => block.type === "tool_use");
-				if (toolUses.length) wireToolCalls = toolUses.map((block) => ({
-					id: block.id,
-					type: "function",
-					function: {
-						name: block.name,
-						arguments: JSON.stringify(block.input ?? {})
-					}
-				}));
-			}
-			return {
-				choices: [{ message: {
-					content: text,
-					...wireToolCalls ? { tool_calls: wireToolCalls } : {}
-				} }],
-				usage: {
-					prompt_tokens: response.usage?.input_tokens,
-					completion_tokens: response.usage?.output_tokens,
-					total_tokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0)
+	return {
+		supportsJsonObjectMode: false,
+		chat: { completions: {
+			async create(params, options$1) {
+				const { body, toolName } = buildAnthropicRequestBody(params, nativeStructuredOutputModels, effortTokenTable, adaptiveOnlyModels);
+				const response = await anthropicClient.messages.create(body, options$1);
+				let text;
+				let wireToolCalls;
+				if (toolName) {
+					const toolUse = response.content.find((block) => block.type === "tool_use" && block.name === toolName);
+					if (!toolUse) throw new LLMError(`Anthropic did not return the required structured output tool "${toolName}".`, "validation");
+					if (!toolUse.input || typeof toolUse.input !== "object" || Array.isArray(toolUse.input)) throw new LLMError(`Anthropic returned invalid structured output for tool "${toolName}". Expected an object.`, "validation");
+					text = JSON.stringify(toolUse.input);
+				} else {
+					text = response.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+					const toolUses = response.content.filter((block) => block.type === "tool_use");
+					if (toolUses.length) wireToolCalls = toolUses.map((block) => ({
+						id: block.id,
+						type: "function",
+						function: {
+							name: block.name,
+							arguments: JSON.stringify(block.input ?? {})
+						}
+					}));
 				}
-			};
-		},
-		async *createStream(params, options$1) {
-			const { body, toolName } = buildAnthropicRequestBody(params, nativeStructuredOutputModels);
-			const stream = await rawMessagesCreate({
-				...body,
-				stream: true
-			}, options$1);
-			const blockKinds = new Map();
-			let inputTokens = 0;
-			let sawJsonTool = false;
-			for await (const event of stream) if (event.type === "message_start") inputTokens = event.message.usage?.input_tokens ?? 0;
-			else if (event.type === "content_block_start") if (event.content_block.type === "tool_use") {
-				const kind = event.content_block.name === toolName ? "json-tool" : "tool_use";
-				blockKinds.set(event.index, kind);
-				if (kind === "json-tool") sawJsonTool = true;
-				else if (!toolName) yield {
-					type: "tool_call_delta",
-					index: event.index,
-					id: event.content_block.id,
-					name: event.content_block.name
+				return {
+					choices: [{ message: {
+						content: text,
+						...wireToolCalls ? { tool_calls: wireToolCalls } : {}
+					} }],
+					usage: {
+						prompt_tokens: response.usage?.input_tokens,
+						completion_tokens: response.usage?.output_tokens,
+						total_tokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
+						...response.usage?.output_tokens_details?.thinking_tokens !== void 0 ? { completion_tokens_details: { reasoning_tokens: response.usage.output_tokens_details.thinking_tokens } } : {}
+					}
 				};
-			} else blockKinds.set(event.index, "text");
-			else if (event.type === "content_block_delta") {
-				if (event.delta.type === "text_delta") {
-					if (!toolName) yield {
-						type: "text-delta",
-						delta: event.delta.text
-					};
-				} else if (event.delta.type === "input_json_delta") {
-					const kind = blockKinds.get(event.index);
-					if (kind === "json-tool") yield {
-						type: "text-delta",
-						delta: event.delta.partial_json
-					};
+			},
+			async *createStream(params, options$1) {
+				const { body, toolName } = buildAnthropicRequestBody(params, nativeStructuredOutputModels, effortTokenTable, adaptiveOnlyModels);
+				const stream = await rawMessagesCreate({
+					...body,
+					stream: true
+				}, options$1);
+				const blockKinds = new Map();
+				let inputTokens = 0;
+				let sawJsonTool = false;
+				for await (const event of stream) if (event.type === "message_start") inputTokens = event.message.usage?.input_tokens ?? 0;
+				else if (event.type === "content_block_start") if (event.content_block.type === "tool_use") {
+					const kind = event.content_block.name === toolName ? "json-tool" : "tool_use";
+					blockKinds.set(event.index, kind);
+					if (kind === "json-tool") sawJsonTool = true;
 					else if (!toolName) yield {
 						type: "tool_call_delta",
 						index: event.index,
-						argumentsDelta: event.delta.partial_json
+						id: event.content_block.id,
+						name: event.content_block.name
 					};
-				}
-			} else if (event.type === "message_delta") {
-				const outputTokens = event.usage?.output_tokens ?? 0;
-				yield {
-					type: "usage",
-					usage: {
-						prompt_tokens: inputTokens,
-						completion_tokens: outputTokens,
-						total_tokens: inputTokens + outputTokens
+				} else blockKinds.set(event.index, "text");
+				else if (event.type === "content_block_delta") {
+					if (event.delta.type === "text_delta") {
+						if (!toolName) yield {
+							type: "text-delta",
+							delta: event.delta.text
+						};
+					} else if (event.delta.type === "input_json_delta") {
+						const kind = blockKinds.get(event.index);
+						if (kind === "json-tool") yield {
+							type: "text-delta",
+							delta: event.delta.partial_json
+						};
+						else if (!toolName) yield {
+							type: "tool_call_delta",
+							index: event.index,
+							argumentsDelta: event.delta.partial_json
+						};
 					}
-				};
-			} else if (event.type === "ping") yield { type: "ping" };
-			if (toolName && !sawJsonTool) throw new LLMError(`Anthropic did not return the required structured output tool "${toolName}".`, "validation");
-		}
-	} } };
+				} else if (event.type === "message_delta") {
+					const outputTokens = event.usage?.output_tokens ?? 0;
+					const thinkingTokens = event.usage?.output_tokens_details?.thinking_tokens;
+					yield {
+						type: "usage",
+						usage: {
+							prompt_tokens: inputTokens,
+							completion_tokens: outputTokens,
+							total_tokens: inputTokens + outputTokens,
+							...thinkingTokens !== void 0 ? { completion_tokens_details: { reasoning_tokens: thinkingTokens } } : {}
+						}
+					};
+				} else if (event.type === "ping") yield { type: "ping" };
+				if (toolName && !sawJsonTool) throw new LLMError(`Anthropic did not return the required structured output tool "${toolName}".`, "validation");
+			}
+		} }
+	};
 }
 /**
 * Anthropic requires strict role alternation, so the per-wire-message
@@ -3288,12 +3793,23 @@ function parseToolArguments(text, toolName) {
 	if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new LLMError(`Tool call "${toolName}" arguments must be a JSON object.`, "validation");
 	return parsed;
 }
+/**
+* Parses a wire tool message's `content` into the object Gemini's
+* `functionResponse.response` expects. Gemini (and the real SDK's
+* `FunctionResponse.response` type) requires an object, so a result that
+* parses to something other than a plain JSON object (a string, number,
+* array, or unparseable text) is wrapped under an `output` key, mirroring
+* Gemini's own documented convention for non-object function results.
+*/
 function parseToolResult(text) {
+	let parsed;
 	try {
-		return text.trim() ? JSON.parse(text) : "";
+		parsed = text.trim() ? JSON.parse(text) : "";
 	} catch {
-		return text;
+		parsed = text;
 	}
+	if (parsed && !Array.isArray(parsed) && typeof parsed === "object") return parsed;
+	return { output: parsed };
 }
 /**
 * Gemini expects the results of everything the model asked for in one turn
@@ -3322,7 +3838,7 @@ function mergeConsecutiveFunctionResponses(contents) {
 * `abortSignal` is folded into `config` by the caller (`create`/
 * `createStream`), once the request options are available.
 */
-function buildGeminiRequest(params) {
+function buildGeminiRequest(params, effortTokenTable, thinkingLevelModels) {
 	const systemMessage = params.messages.find((m) => m.role === "system");
 	const conversationMessages = params.messages.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "tool");
 	const wantsJson = Boolean(params.response_format);
@@ -3347,51 +3863,37 @@ function buildGeminiRequest(params) {
 		})) }];
 		config.toolConfig = toGeminiToolConfig(params.tool_choice);
 	}
+	if (usesGeminiThinkingLevel(params.model, thinkingLevelModels)) {
+		const effortTier = params.reasoning_effort ?? (params.budget_tokens !== void 0 ? budgetTokensToEffort(params.budget_tokens, effortTokenTable) : void 0);
+		if (effortTier !== void 0) config.thinkingConfig = { thinkingLevel: toGeminiThinkingLevel(effortTier, params.model) };
+	} else {
+		const thinkingBudget = params.budget_tokens ?? (params.reasoning_effort ? effortToBudgetTokens(params.reasoning_effort, effortTokenTable) : void 0);
+		if (thinkingBudget !== void 0) config.thinkingConfig = { thinkingBudget };
+	}
 	return {
 		model: params.model,
 		contents: mergeConsecutiveFunctionResponses(conversationMessages.map((m) => toGeminiContent(m))),
 		config
 	};
 }
-/**
-* Wraps a Gemini client so it satisfies the `LLMClient` interface VernLLM
-* uses for OpenAI-compatible APIs. Gemini's shape differs on nearly every
-* axis: a `contents` array instead of `messages`, a separate
-* `systemInstruction` field instead of a `system` role message,
-* `generationConfig` instead of top-level `temperature`/`max_tokens`, and
-* native JSON Schema support via `responseMimeType: 'application/json'` +
-* `responseSchema`. `reasoning_effort` has no equivalent. Gemini's thinking
-* models use a token budget, not an effort tier, so it's dropped, same as
-* Anthropic.
-*
-* `tools` maps to Gemini's native `functionDeclarations`/`functionCall`;
-* `tool_choice` maps to `toolConfig.functionCallingConfig`. Gemini accepts
-* `responseSchema` and `tools` in the same request natively, so both are
-* set independently here and no special-casing is needed for the
-* combination, unlike `fromAnthropic`/`fromBedrock`.
-*
-* `createStream` calls `generateContentStream` (optional on `GeminiClient`
-*, required only if the caller sets `stream: true`) and translates each
-* partial response into `WireStreamChunk`s. Unlike OpenAI/Anthropic,
-* Gemini's own function-calling API doesn't stream tool-call arguments
-* incrementally: a `functionCall` part always arrives whole in one chunk,
-* so each one is emitted as a single, complete `tool_call_delta` (a
-* one-shot "delta" containing the full arguments) rather than accumulated
-* fragments, that's a real difference in the underlying API, not
-* something this adapter can smooth over. `usageMetadata` is (per Gemini's
-* own behavior) only reliably present on the last chunk, so the `usage`
-* `WireStreamChunk` is emitted once, after the stream completes, from
-* whichever chunk's `usageMetadata` was seen last.
-*/
-function fromGemini(geminiClient) {
+function fromGemini(client, options) {
+	const effortTokenTable = resolveEffortTokenTable(options?.reasoningEffortTokens);
+	const thinkingLevelModels = options?.thinkingLevelModels;
+	const resolved = client.models ?? client;
+	if (typeof resolved.generateContent !== "function") throw new LLMError("fromGemini requires a client with generateContent: pass ai.models, or the whole ai client (fromGemini(ai)).", "invalid_params", {
+		code: "unsupported_capability",
+		issues: { capability: "generateContent" }
+	});
+	const generateContent = resolved.generateContent.bind(resolved);
+	const generateContentStream = typeof resolved.generateContentStream === "function" ? resolved.generateContentStream.bind(resolved) : void 0;
 	return { chat: { completions: {
-		async create(params, options) {
-			const request = buildGeminiRequest(params);
+		async create(params, options$1) {
+			const request = buildGeminiRequest(params, effortTokenTable, thinkingLevelModels);
 			request.config = {
 				...request.config,
-				abortSignal: options.signal
+				abortSignal: options$1.signal
 			};
-			const response = await geminiClient.generateContent(request);
+			const response = await generateContent(request);
 			const parts = response.candidates?.[0]?.content?.parts ?? [];
 			const text = parts.map((p) => p.text ?? "").join("");
 			const functionCalls = parts.filter((p) => p.functionCall);
@@ -3412,21 +3914,22 @@ function fromGemini(geminiClient) {
 				usage: {
 					prompt_tokens: response.usageMetadata?.promptTokenCount,
 					completion_tokens: response.usageMetadata?.candidatesTokenCount,
-					total_tokens: response.usageMetadata?.totalTokenCount
+					total_tokens: response.usageMetadata?.totalTokenCount,
+					...response.usageMetadata?.thoughtsTokenCount !== void 0 ? { completion_tokens_details: { reasoning_tokens: response.usageMetadata.thoughtsTokenCount } } : {}
 				}
 			};
 		},
-		async *createStream(params, options) {
-			if (!geminiClient.generateContentStream) throw new LLMError("stream: true requires a Gemini client with generateContentStream", "invalid_params", {
+		async *createStream(params, options$1) {
+			if (!generateContentStream) throw new LLMError("stream: true requires a Gemini client with generateContentStream", "invalid_params", {
 				code: "unsupported_capability",
 				issues: { capability: "generateContentStream" }
 			});
-			const request = buildGeminiRequest(params);
+			const request = buildGeminiRequest(params, effortTokenTable, thinkingLevelModels);
 			request.config = {
 				...request.config,
-				abortSignal: options.signal
+				abortSignal: options$1.signal
 			};
-			const stream = await geminiClient.generateContentStream(request);
+			const stream = await generateContentStream(request);
 			let toolCallIndex = 0;
 			let lastUsage;
 			for await (const chunk of stream) {
@@ -3455,7 +3958,8 @@ function fromGemini(geminiClient) {
 				usage: {
 					prompt_tokens: lastUsage.promptTokenCount,
 					completion_tokens: lastUsage.candidatesTokenCount,
-					total_tokens: lastUsage.totalTokenCount
+					total_tokens: lastUsage.totalTokenCount,
+					...lastUsage.thoughtsTokenCount !== void 0 ? { completion_tokens_details: { reasoning_tokens: lastUsage.thoughtsTokenCount } } : {}
 				}
 			};
 		}
@@ -3464,6 +3968,19 @@ function fromGemini(geminiClient) {
 
 //#endregion
 //#region src/adapters/bedrock.ts
+/**
+* Default heuristic for whether a Bedrock model id is a Claude model,
+* matching AWS's own `anthropic.claude-*`/`us.anthropic.claude-*` naming.
+* Only used to decide whether a reasoning token budget is worth forwarding
+* through `additionalModelRequestFields`, not a general capability check,
+* so a plain substring match is enough, no override hook needed the way
+* `nativeStructuredOutputModels`/`toolUseSupportedModels` have one: a
+* false positive here just sends an inert extra field, not a request that
+* fails outright.
+*/
+function isClaudeModel(model) {
+	return model.includes("claude");
+}
 /** Maps a `ContentBlock` image MIME type, already validated, to Converse's `format` enum. */
 function toBedrockImageFormat(mimeType) {
 	switch (assertSupportedImageMimeType(mimeType)) {
@@ -3530,7 +4047,7 @@ function buildBedrockToolConfig(tools, toolChoiceParam) {
 * normal, non-forced tool-call handling both `create` and `createStream`
 * already do when `toolName` is unset.
 */
-function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOutputModels) {
+function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOutputModels, effortTokenTable, adaptiveOnlyModels) {
 	const systemMessage = params.messages.find((m) => m.role === "system");
 	const conversationMessages = params.messages.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "tool");
 	const jsonSchema = params.response_format?.type === "json_schema" ? params.response_format.json_schema : void 0;
@@ -3538,8 +4055,8 @@ function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOut
 	if (jsonSchema && !schemaName) throw new LLMError("json_schema.name must not be empty.", "validation");
 	const isNative = Boolean(jsonSchema) && supportsNativeStructuredOutput(params.model, nativeStructuredOutputModels);
 	if (jsonSchema && params.tools?.length && !isNative) throw new LLMError(`Bedrock model "${params.model}" is not covered by nativeStructuredOutputModels, so \`jsonSchema\` is emulated as a forced single tool call there (via \`toolConfig\`), which collides with the \`tools\` you also provided. Either drop \`tools\` or \`jsonSchema\` for this call, or pass this model in fromBedrock's \`nativeStructuredOutputModels\` option once you've confirmed it supports Converse's \`outputConfig.textFormat\`.`, "validation");
+	if (params.response_format?.type === "json_object") throw new LLMError("response_format: \"json_object\" is not supported on Bedrock. Converse has no field that mechanically guarantees valid JSON output for this mode, so it used to be emulated by injecting a \"respond with JSON only\" instruction into the system prompt, a guarantee this adapter can no longer make. Use `jsonSchema` instead, which maps to a real constraint (Converse's native outputConfig.textFormat on covered models, or a forced tool call otherwise).", "validation");
 	let toolName;
-	let jsonInstruction;
 	let toolConfig;
 	let outputConfig;
 	if (jsonSchema && isNative) {
@@ -3564,7 +4081,7 @@ function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOut
 			} }],
 			toolChoice: { tool: { name: toolName } }
 		};
-	} else if (params.response_format?.type === "json_object") jsonInstruction = "Respond with valid JSON only, no prose or markdown fences.";
+	}
 	if (params.tools?.length && !toolName) toolConfig = buildBedrockToolConfig(params.tools, params.tool_choice);
 	if (jsonSchema && toolConfig && toolUseSupportedModels) {
 		const isSupported = Array.isArray(toolUseSupportedModels) ? toolUseSupportedModels.includes(params.model) : toolUseSupportedModels(params.model);
@@ -3573,17 +4090,39 @@ function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOut
 			issues: { capability: "toolUseSupportedModels" }
 		});
 	}
-	const systemParts = [systemMessage?.content, jsonInstruction].filter((s) => Boolean(s));
+	let additionalModelRequestFields;
+	let effort;
+	if (isClaudeModel(params.model) && (params.budget_tokens !== void 0 || params.reasoning_effort !== void 0)) {
+		const forcedToolChoice = toolConfig?.toolChoice;
+		assertNoForcedToolChoiceWithThinking(forcedToolChoice && "tool" in forcedToolChoice ? `toolChoice forcing the "${forcedToolChoice.tool?.name}" tool` : forcedToolChoice && "any" in forcedToolChoice ? "toolChoice: 'required' (Converse's \"any\" tool_choice)" : void 0);
+		if (supportsManualThinkingBudget(params.model, adaptiveOnlyModels)) {
+			const budgetTokens = params.budget_tokens ?? effortToBudgetTokens(params.reasoning_effort, effortTokenTable);
+			assertValidClaudeBudgetTokens(budgetTokens, params.max_tokens);
+			additionalModelRequestFields = { thinking: {
+				type: "enabled",
+				budget_tokens: budgetTokens
+			} };
+		} else {
+			const effortTier = params.reasoning_effort ?? budgetTokensToEffort(params.budget_tokens, effortTokenTable);
+			additionalModelRequestFields = { thinking: { type: "adaptive" } };
+			effort = toClaudeAdaptiveEffort(effortTier);
+		}
+	}
+	const temperature = additionalModelRequestFields ? void 0 : params.temperature;
 	const request = {
 		modelId: params.model,
 		messages: mergeConsecutiveToolResults(conversationMessages.map((m) => toBedrockMessage(m))),
-		system: systemParts.length ? systemParts.map((text) => ({ text })) : void 0,
+		system: systemMessage?.content ? [{ text: systemMessage.content }] : void 0,
 		inferenceConfig: {
-			...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+			...temperature !== void 0 ? { temperature } : {},
 			maxTokens: params.max_tokens
 		},
 		...toolConfig ? { toolConfig } : {},
-		...outputConfig ? { outputConfig } : {}
+		...outputConfig || effort ? { outputConfig: {
+			...outputConfig ?? {},
+			...effort ? { effort } : {}
+		} } : {},
+		...additionalModelRequestFields ? { additionalModelRequestFields } : {}
 	};
 	return {
 		request,
@@ -3591,6 +4130,120 @@ function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOut
 	};
 }
 /**
+* Distinguishes a real AWS SDK v3 client (`.send(command)`) from a
+* hand-written `BedrockConverseClient` (`.converse(params)`) purely
+* structurally, so `fromBedrock` can accept either without the caller
+* saying which one they're passing. The two shapes don't overlap: nothing
+* implementing `.converse()` would also need `.send()`.
+*/
+function isAwsSendClient(client) {
+	return typeof client.send === "function";
+}
+/**
+* Narrows one raw AWS stream event down to VernLLM's intentionally minimal
+* `BedrockConverseStreamEvent` union. Returns `undefined` if the event
+* isn't one of the kinds this adapter models.
+*
+* AWS's real `ConverseStreamOutput` type is a strictly larger union than
+* `BedrockConverseStreamEvent`. On top of every member modeled here, it
+* also includes a generated `$unknown` member, AWS's forward-compatibility
+* escape hatch for event kinds added to the service after this SDK version
+* was generated. A blind type assertion from one union to the other would
+* compile, but would let `$unknown` (or any other future member) reach
+* `fromBedrock`'s event-handling loop unnarrowed, as if it were one of the
+* kinds actually handled there.
+*
+* Returning `undefined` for anything unrecognized, filtered out by
+* `normalizeBedrockEventStream` below, keeps two guarantees. AWS SDK
+* generated types never leak into `fromBedrock`'s application code, only
+* this module's own `BedrockConverseStreamEvent` shape does. An event kind
+* this adapter doesn't yet know about is silently skipped, the same
+* forward-compatible behavior AWS's own `$unknown` convention implies,
+* rather than crashing the stream or being misrouted into a handler that
+* doesn't actually match its shape.
+*/
+function normalizeBedrockStreamEvent(raw) {
+	if ("messageStart" in raw) return { messageStart: raw.messageStart };
+	if ("contentBlockStart" in raw) return { contentBlockStart: raw.contentBlockStart };
+	if ("contentBlockDelta" in raw) return { contentBlockDelta: raw.contentBlockDelta };
+	if ("contentBlockStop" in raw) return { contentBlockStop: raw.contentBlockStop };
+	if ("messageStop" in raw) return { messageStop: raw.messageStop };
+	if ("metadata" in raw) return { metadata: raw.metadata };
+	if ("internalServerException" in raw) return { internalServerException: raw.internalServerException };
+	if ("modelStreamErrorException" in raw) return { modelStreamErrorException: raw.modelStreamErrorException };
+	if ("validationException" in raw) return { validationException: raw.validationException };
+	if ("throttlingException" in raw) return { throttlingException: raw.throttlingException };
+	if ("serviceUnavailableException" in raw) return { serviceUnavailableException: raw.serviceUnavailableException };
+	return void 0;
+}
+/**
+* Wraps a raw AWS event stream, narrowing each event through
+* `normalizeBedrockStreamEvent` and filtering out anything that doesn't
+* map onto `BedrockConverseStreamEvent`. `fromBedrock`'s event loop only
+* ever sees the shapes it actually models.
+*/
+async function* normalizeBedrockEventStream(rawStream) {
+	for await (const raw of rawStream) {
+		const event = normalizeBedrockStreamEvent(raw);
+		if (event) yield event;
+	}
+}
+/**
+* Adapts a real AWS SDK v3 client (anything with `.send()`, matching
+* `BedrockRuntimeClient`) into a `BedrockConverseClient`, so `fromBedrock`
+* can accept either without a hand-written `.converse()`/`.converseStream()`
+* wrapper. Internally does what that wrapper would: `client.send(new
+* ConverseCommand(params))`, `client.send(new
+* ConverseStreamCommand(params))`.
+*
+* `@aws-sdk/client-bedrock-runtime` is intentionally not a dependency (not
+* even a peer dependency) of this package. `vern-llm` otherwise has zero
+* runtime dependencies, and every other adapter works the same way:
+* structural typing over whatever client the caller already has. Instead,
+* `ConverseCommand`/`ConverseStreamCommand` are pulled in with a dynamic
+* `import()` the first time either method actually runs, and memoized
+* after that. Nothing is added to `package.json`, static or peer.
+* Bundlers only pull the AWS SDK in for code paths that actually pass a
+* raw AWS client to `fromBedrock`; a hand-written `BedrockConverseClient`
+* stays unaffected. If `@aws-sdk/client-bedrock-runtime` isn't installed,
+* the failure is a clear `LLMError` naming exactly what's missing, at the
+* moment it's needed, rather than a silent peer-dependency warning at
+* install time or a raw "Cannot find module" a caller has to trace back
+* themselves.
+*
+* Also closes two structural gaps between AWS's generated types and
+* `BedrockConverseClient`. AWS's `ConverseStreamCommandOutput.stream` is
+* optional, a response may not include it. This throws a clear `LLMError`
+* instead of letting `undefined` reach `fromBedrock`'s `for await` loop.
+* AWS's `ConverseStreamOutput` union is larger than
+* `BedrockConverseStreamEvent`, it includes a generated `$unknown` member.
+* Every event is narrowed through `normalizeBedrockStreamEvent` before it
+* reaches application code, instead of being asserted wholesale from one
+* type to the other.
+*/
+function wrapAwsSendClient(client) {
+	let commandsPromise;
+	function loadCommands() {
+		commandsPromise ??= import("@aws-sdk/client-bedrock-runtime").then((mod) => mod, (cause) => {
+			commandsPromise = void 0;
+			throw new LLMError("fromBedrock requires \"@aws-sdk/client-bedrock-runtime\" to be installed to use a raw AWS SDK client (it is not a dependency of vern-llm itself). Install it, or pass your own object with .converse()/.converseStream() methods instead.", "validation", { cause });
+		});
+		return commandsPromise;
+	}
+	return {
+		converse: async (params, requestOptions) => {
+			const { ConverseCommand } = await loadCommands();
+			return client.send(new ConverseCommand(params), { abortSignal: requestOptions.signal });
+		},
+		converseStream: async (params, requestOptions) => {
+			const { ConverseStreamCommand } = await loadCommands();
+			const result = await client.send(new ConverseStreamCommand(params), { abortSignal: requestOptions.signal });
+			if (!result.stream) throw new LLMError("Bedrock ConverseStreamCommand response did not include a stream. This can happen if the request or the model doesn't actually support Converse streaming.", "api", { code: "server_error" });
+			return { stream: normalizeBedrockEventStream(result.stream) };
+		}
+	};
+}
+/**
 * Wraps a Bedrock Converse-API client so it satisfies the `LLMClient`
 * interface VernLLM uses for OpenAI/Groq. The Converse API is unified
 * across Bedrock's model families (Anthropic, Titan, Llama, Mistral, etc.),
@@ -3598,6 +4251,16 @@ function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOut
 * regardless of which underlying model `modelId` points at, as long as
 * that model supports Converse (most current-generation ones do)
 *
+* `bedrockClient` accepts either a hand-written `BedrockConverseClient`
+* (a `.converse()`/`.converseStream()` wrapper you provide) or a real AWS
+* SDK v3 client (anything with `.send()`, matching `BedrockRuntimeClient`)
+* directly, detected structurally. Passing a raw AWS client skips the
+* hand-written wrapper entirely, internally doing what it would
+* (`send(new ConverseCommand(...))`, `send(new
+* ConverseStreamCommand(...))`). See `wrapAwsSendClient` for how that path
+* is implemented, including why `@aws-sdk/client-bedrock-runtime` stays
+* out of this package's dependencies either way.
+*
 * `response_format: json_schema`, on a model covered by
 * `options.nativeStructuredOutputModels` (opt-in, unset by default), is
 * sent as `outputConfig.textFormat`, its own request field, independent of
@@ -3619,12 +4282,15 @@ function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOut
 * `BedrockAdapterOptions`), otherwise a `jsonSchema` call to an
 * unsupported model surfaces Bedrock's raw error unchanged.
 *
-* `response_format: json_object` (no schema to build a tool from) and
-* `reasoning_effort` (no Converse equivalent) fall back to a system-prompt
-* instruction and are dropped respectively. Unlike `jsonSchema`,
-* `json_object` combines with real `tools` freely on every model: it's a
-* prompt nudge, not a request field, so there's nothing for it to collide
-* with.
+* `response_format: json_object` throws `LLMError('validation')`: Converse
+* has no field that mechanically guarantees JSON output, and the only way
+* to emulate it was an unenforced system-prompt instruction, a guarantee
+* this adapter no longer pretends to make. Use `jsonSchema` instead.
+* `reasoning_effort` (no Converse equivalent) is converted to a token
+* budget and forwarded via `additionalModelRequestFields` for Claude
+* models only; `budget_tokens` is forwarded the same way directly. Both
+* are silently dropped for non-Claude models, which have no equivalent
+* field to reach for. See `adapters/internal/reasoningBudget.utils.ts`.
 *
 * `tools` alone maps to Converse's native `toolConfig`/`toolUse`/
 * `toolResult`; `tool_choice` maps to `toolConfig.toolChoice`.
@@ -3642,107 +4308,113 @@ function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOut
 * `create` branch above unwraps it.
 */
 function fromBedrock(bedrockClient, options) {
+	const client = isAwsSendClient(bedrockClient) ? wrapAwsSendClient(bedrockClient) : bedrockClient;
 	const toolUseSupportedModels = options?.toolUseSupportedModels;
 	const nativeStructuredOutputModels = options?.nativeStructuredOutputModels;
-	return { chat: { completions: {
-		async create(params, requestOptions) {
-			const { request, toolName } = buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOutputModels);
-			const response = await bedrockClient.converse(request, requestOptions);
-			let text;
-			let wireToolCalls;
-			if (toolName) {
-				const toolUseBlock = response.output?.message?.content?.find((block) => block.toolUse?.name === toolName);
-				text = toolUseBlock?.toolUse ? JSON.stringify(toolUseBlock.toolUse.input) : "";
-			} else {
-				const blocks = response.output?.message?.content ?? [];
-				text = blocks.map((c) => c.text ?? "").join("");
-				const toolUses = blocks.filter((block) => Boolean(block.toolUse));
-				if (toolUses.length) wireToolCalls = toolUses.map((block, i) => {
-					const toolUse = block.toolUse;
-					if (!toolUse.name) throw new LLMError(`Bedrock returned a toolUse block without a name at index ${i}.`, "validation");
-					return {
-						id: toolUse.toolUseId ?? `${toolUse.name}_${i}`,
-						type: "function",
-						function: {
-							name: toolUse.name,
-							arguments: JSON.stringify(toolUse.input ?? {})
-						}
-					};
-				});
-			}
-			return {
-				choices: [{ message: {
-					content: text,
-					...wireToolCalls ? { tool_calls: wireToolCalls } : {}
-				} }],
-				usage: {
-					prompt_tokens: response.usage?.inputTokens,
-					completion_tokens: response.usage?.outputTokens,
-					total_tokens: response.usage?.totalTokens
+	const effortTokenTable = resolveEffortTokenTable(options?.reasoningEffortTokens);
+	const adaptiveOnlyModels = options?.adaptiveOnlyModels;
+	return {
+		supportsJsonObjectMode: false,
+		chat: { completions: {
+			async create(params, requestOptions) {
+				const { request, toolName } = buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOutputModels, effortTokenTable, adaptiveOnlyModels);
+				const response = await client.converse(request, requestOptions);
+				let text;
+				let wireToolCalls;
+				if (toolName) {
+					const toolUseBlock = response.output?.message?.content?.find((block) => block.toolUse?.name === toolName);
+					text = toolUseBlock?.toolUse ? JSON.stringify(toolUseBlock.toolUse.input) : "";
+				} else {
+					const blocks = response.output?.message?.content ?? [];
+					text = blocks.map((c) => c.text ?? "").join("");
+					const toolUses = blocks.filter((block) => Boolean(block.toolUse));
+					if (toolUses.length) wireToolCalls = toolUses.map((block, i) => {
+						const toolUse = block.toolUse;
+						if (!toolUse.name) throw new LLMError(`Bedrock returned a toolUse block without a name at index ${i}.`, "validation");
+						return {
+							id: toolUse.toolUseId ?? `${toolUse.name}_${i}`,
+							type: "function",
+							function: {
+								name: toolUse.name,
+								arguments: JSON.stringify(toolUse.input ?? {})
+							}
+						};
+					});
 				}
-			};
-		},
-		async *createStream(params, requestOptions) {
-			if (!bedrockClient.converseStream) throw new LLMError("stream: true requires a Bedrock client with converseStream", "invalid_params", {
-				code: "unsupported_capability",
-				issues: { capability: "converseStream" }
-			});
-			const { request, toolName } = buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOutputModels);
-			const { stream } = await bedrockClient.converseStream(request, requestOptions);
-			const blockKinds = new Map();
-			for await (const event of stream) if ("contentBlockStart" in event) {
-				const { contentBlockIndex, start } = event.contentBlockStart;
-				if (start?.toolUse) {
-					const kind = start.toolUse.name === toolName ? "json-tool" : "tool_use";
-					blockKinds.set(contentBlockIndex, kind);
-					if (kind === "tool_use" && !toolName) yield {
-						type: "tool_call_delta",
-						index: contentBlockIndex,
-						id: start.toolUse.toolUseId,
-						name: start.toolUse.name
-					};
-				} else blockKinds.set(contentBlockIndex, "text");
-			} else if ("contentBlockDelta" in event) {
-				const { contentBlockIndex, delta } = event.contentBlockDelta;
-				if (delta && "text" in delta && delta.text !== void 0 && !toolName) yield {
-					type: "text-delta",
-					delta: delta.text
+				return {
+					choices: [{ message: {
+						content: text,
+						...wireToolCalls ? { tool_calls: wireToolCalls } : {}
+					} }],
+					usage: {
+						prompt_tokens: response.usage?.inputTokens,
+						completion_tokens: response.usage?.outputTokens,
+						total_tokens: response.usage?.totalTokens
+					}
 				};
-				else if (delta && "toolUse" in delta && delta.toolUse?.input !== void 0) {
-					const kind = blockKinds.get(contentBlockIndex);
-					if (kind === "json-tool") yield {
+			},
+			async *createStream(params, requestOptions) {
+				if (!client.converseStream) throw new LLMError("stream: true requires a Bedrock client with converseStream", "invalid_params", {
+					code: "unsupported_capability",
+					issues: { capability: "converseStream" }
+				});
+				const { request, toolName } = buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOutputModels, effortTokenTable, adaptiveOnlyModels);
+				const { stream } = await client.converseStream(request, requestOptions);
+				const blockKinds = new Map();
+				for await (const event of stream) if ("contentBlockStart" in event) {
+					const { contentBlockIndex, start } = event.contentBlockStart;
+					if (start?.toolUse) {
+						const kind = start.toolUse.name === toolName ? "json-tool" : "tool_use";
+						blockKinds.set(contentBlockIndex, kind);
+						if (kind === "tool_use" && !toolName) yield {
+							type: "tool_call_delta",
+							index: contentBlockIndex,
+							id: start.toolUse.toolUseId,
+							name: start.toolUse.name
+						};
+					} else blockKinds.set(contentBlockIndex, "text");
+				} else if ("contentBlockDelta" in event) {
+					const { contentBlockIndex, delta } = event.contentBlockDelta;
+					if (delta && "text" in delta && delta.text !== void 0 && !toolName) yield {
 						type: "text-delta",
-						delta: delta.toolUse.input
+						delta: delta.text
 					};
-					else if (!toolName) yield {
-						type: "tool_call_delta",
-						index: contentBlockIndex,
-						argumentsDelta: delta.toolUse.input
-					};
-				}
-			} else if ("metadata" in event && event.metadata.usage) yield {
-				type: "usage",
-				usage: {
-					prompt_tokens: event.metadata.usage.inputTokens,
-					completion_tokens: event.metadata.usage.outputTokens,
-					total_tokens: event.metadata.usage.totalTokens
-				}
-			};
-			else if ("throttlingException" in event) throw new LLMError(event.throttlingException.message ?? "Bedrock throttled the request mid-stream", "api", {
-				status: 429,
-				code: "provider_rate_limited"
-			});
-			else if ("validationException" in event) throw new LLMError(event.validationException.message ?? "Bedrock rejected the request mid-stream", "validation");
-			else if ("internalServerException" in event || "serviceUnavailableException" in event || "modelStreamErrorException" in event) {
-				const detail = "internalServerException" in event && event.internalServerException.message || "serviceUnavailableException" in event && event.serviceUnavailableException.message || "modelStreamErrorException" in event && event.modelStreamErrorException.message || "Bedrock reported a mid-stream error";
-				const status = "modelStreamErrorException" in event && event.modelStreamErrorException.originalStatusCode || "serviceUnavailableException" in event && 503 || 500;
-				throw new LLMError(detail, "api", {
-					status,
-					code: status >= 500 ? "server_error" : void 0
+					else if (delta && "toolUse" in delta && delta.toolUse?.input !== void 0) {
+						const kind = blockKinds.get(contentBlockIndex);
+						if (kind === "json-tool") yield {
+							type: "text-delta",
+							delta: delta.toolUse.input
+						};
+						else if (!toolName) yield {
+							type: "tool_call_delta",
+							index: contentBlockIndex,
+							argumentsDelta: delta.toolUse.input
+						};
+					}
+				} else if ("metadata" in event && event.metadata.usage) yield {
+					type: "usage",
+					usage: {
+						prompt_tokens: event.metadata.usage.inputTokens,
+						completion_tokens: event.metadata.usage.outputTokens,
+						total_tokens: event.metadata.usage.totalTokens
+					}
+				};
+				else if ("throttlingException" in event) throw new LLMError(event.throttlingException.message ?? "Bedrock throttled the request mid-stream", "api", {
+					status: 429,
+					code: "provider_rate_limited"
 				});
+				else if ("validationException" in event) throw new LLMError(event.validationException.message ?? "Bedrock rejected the request mid-stream", "validation");
+				else if ("internalServerException" in event || "serviceUnavailableException" in event || "modelStreamErrorException" in event) {
+					const detail = "internalServerException" in event && event.internalServerException.message || "serviceUnavailableException" in event && event.serviceUnavailableException.message || "modelStreamErrorException" in event && event.modelStreamErrorException.message || "Bedrock reported a mid-stream error";
+					const status = "modelStreamErrorException" in event && event.modelStreamErrorException.originalStatusCode || "serviceUnavailableException" in event && 503 || 500;
+					throw new LLMError(detail, "api", {
+						status,
+						code: status >= 500 ? "server_error" : void 0
+					});
+				}
 			}
-		}
-	} } };
+		} }
+	};
 }
 /** Maps VernLLM's OpenAI-shaped wire `tool_choice` onto Converse's `toolChoice`. */
 function toBedrockToolChoice(toolChoice) {
@@ -3981,6 +4653,22 @@ function fromFetch(config) {
 //#endregion
 //#region src/adapters/openaiCompatible.ts
 /**
+* OpenAI's wire format only understands `reasoning_effort`, not a raw
+* token budget. When the caller set `reasoningEffort`, it's already on
+* `params` and passed through unchanged, this function does nothing.
+* When only `budgetTokens` was set, it's converted to the nearest tier
+* and `budget_tokens` is dropped, since OpenAI's API would otherwise
+* silently ignore an unrecognized field.
+*/
+function applyReasoningBudget(params, effortTokenTable) {
+	if (params.budget_tokens === void 0) return params;
+	const { budget_tokens,...rest } = params;
+	return rest.reasoning_effort !== void 0 ? rest : {
+		...rest,
+		reasoning_effort: budgetTokensToEffort(budget_tokens, effortTokenTable)
+	};
+}
+/**
 * Translates a VernLLM `ContentBlock[]` into OpenAI's wire-level content
 * array. Text blocks become `{ type: 'text', text }`; image blocks become
 * `{ type: 'image_url', image_url: { url } }` with the base64 payload
@@ -4046,23 +4734,24 @@ function* toWireStreamChunks(chunk) {
 function fromOpenAICompatible(client, options = {}) {
 	const raw = client;
 	const { supportsStreamUsage = true } = options;
+	const effortTokenTable = resolveEffortTokenTable(options.reasoningEffortTokens);
 	const rawCreate = raw.chat.completions.create.bind(raw.chat.completions);
 	return { chat: { completions: {
 		async create(params, options$1) {
 			const messages = toOpenAIMessages(params);
-			return raw.chat.completions.create({
+			return raw.chat.completions.create(applyReasoningBudget({
 				...params,
 				messages
-			}, options$1);
+			}, effortTokenTable), options$1);
 		},
 		async *createStream(params, options$1) {
 			const messages = toOpenAIMessages(params);
-			const stream = await rawCreate({
+			const stream = await rawCreate(applyReasoningBudget({
 				...params,
 				messages,
 				stream: true,
 				...supportsStreamUsage ? { stream_options: { include_usage: true } } : {}
-			}, options$1);
+			}, effortTokenTable), options$1);
 			for await (const chunk of stream) yield* toWireStreamChunks(chunk);
 		}
 	} } };
@@ -4186,6 +4875,8 @@ exports.TieredCacheAdapter = TieredCacheAdapter
 exports.VernLLM = VernLLM
 exports.defaultEstimateTokens = defaultEstimateTokens
 exports.defaultFallbackOn = defaultFallbackOn
+exports.defineCachedCallParams = defineCachedCallParams
+exports.defineCallParams = defineCallParams
 exports.from01AI = from01AI
 exports.fromAnthropic = fromAnthropic
 exports.fromAnyscale = fromAnyscale