vern-llm 2.3.0 → 2.4.1

package/dist/index.js

@@ -1,4154 +1,15 @@
-import { randomUUID } from "crypto";
+import{randomUUID as e}from"crypto";const t=new Set([`unknown_tool`,`duplicate_tool_call_id`,`tool_choice_none_violated`,`unexpected_tool_calls`]),n=new Set([`rate_limit_queue_full`,`rate_limit_queue_timeout`,`rate_limit_capacity_exceeded`]),r=new Set([`parse`,`validation`,`invalid_params`,`aborted`]);function i(e,i){return!(r.has(e)||i&&t.has(i)||i&&n.has(i))}function a(e){if(e!==void 0)try{return JSON.stringify(e),e}catch{return`[Unserializable: issues contained a circular reference]`}}function o(e){if(e!==void 0)try{return JSON.parse(JSON.stringify(e))}catch{return`[Unserializable: request body contained a circular reference]`}}const s=new Set([`authorization`,`x-api-key`,`x-goog-api-key`,`api-key`]);function c(e){if(e===void 0)return;let t={};for(let[n,r]of Object.entries(e))s.has(n.toLowerCase())||(t[n]=r);return t}const l=20;function u(e,t=0){if(e!==void 0)return t>=l?[]:e.map(e=>({...e,error:{...e.error,issues:a(e.error.issues),attempts:u(e.error.attempts,t+1)},request:e.request&&{...e.request,body:o(e.request.body),headers:c(e.request.headers)}}))}function d(e,t,n,r,i=Date.now()){return{provider:e,model:t,body:o(n),headers:c(r),startedAt:i}}var f=class extends Error{status;issues;cause;retryAfterMs;code;attempts;constructor(e,t,n={}){super(e),this.type=t,this.name=`LLMError`,this.status=n.status,this.issues=n.issues,this.cause=n.cause,this.retryAfterMs=n.retryAfterMs,this.code=n.code,this.attempts=n.attempts}get retryable(){return i(this.type,this.code)}toSnapshot(){return{message:this.message,type:this.type,status:this.status,issues:a(this.issues),retryAfterMs:this.retryAfterMs,code:this.code,retryable:this.retryable,attempts:u(this.attempts)}}toJSON(){return{name:this.name,message:this.message,type:this.type,status:this.status,issues:a(this.issues),retryAfterMs:this.retryAfterMs,code:this.code,retryable:this.retryable,attempts:u(this.attempts)}}};function p(e){return e instanceof f}function m(e,t){return e.code===t&&e.issues!==void 0}var h=class{store=new Map;constructor(e=1e3){this.maxSize=e}async get(e){let t=this.store.get(e);return t?Date.now()>=t.expiresAt?(this.store.delete(e),{hit:!1,value:null}):{hit:!0,value:t.value}:{hit:!1,value:null}}async set(e,t,n){this.cleanupExpiredEntries(),this.store.set(e,{value:t,expiresAt:Date.now()+n*1e3}),this.enforceSizeLimit()}async delete(e){this.store.delete(e)}cleanupExpiredEntries(){let e=Date.now();for(let[t,n]of this.store)e>=n.expiresAt&&this.store.delete(t)}enforceSizeLimit(){for(;this.store.size>this.maxSize;){let e=this.store.keys().next().value;if(e===void 0)break;this.store.delete(e)}}},g=class{constructor(e=new h){this.inner=e}normalize(e){return e.toLowerCase().trim().replace(/[^\p{L}\p{N}\s]/gu,` `).replace(/\s+/g,` `).trim()}async resolveKey(e){return this.normalize(e)}async get(e){return this.inner.get(this.normalize(e))}async set(e,t,n){await this.inner.set(this.normalize(e),t,n)}async delete(e){await this.inner.delete?.(this.normalize(e))}},_=class{constructor(e,t,n){this.l1=e,this.l2=t,this.l1Ttl=n}async resolveKey(e){return this.l1.resolveKey?this.l1.resolveKey(e):this.l2.resolveKey?this.l2.resolveKey(e):e}async get(e){let t=await this.l1.get(e);if(t.hit)return t;let n=await this.l2.get(e);return n.hit&&await this.l1.set(e,n.value,this.l1Ttl??60),n}async set(e,t,n){await Promise.all([this.l1.set(e,t,this.l1Ttl??n),this.l2.set(e,t,n)])}async delete(e){await Promise.all([this.l1.delete?.(e),this.l2.delete?.(e)])}};function v(e){return typeof e==`object`&&!!e&&`type`in e&&e.type===`tool_calls`&&Array.isArray(e.toolCalls)}const y=new Set([`unknown_tool`,`duplicate_tool_call_id`,`tool_choice_none_violated`,`unexpected_tool_calls`]),b=e=>e.type===`parse`||e.type===`validation`||e.type===`aborted`||e.type===`quota_exceeded`||e.code&&y.has(e.code)?`stop`:`next`;var x=class extends f{constructor(e){let t=e[e.length-1]?.error;super(`${e.length} provider${e.length===1?``:`s`} attempted and failed: ${e.map(e=>`${e.provider}(${e.error.type})`).join(` then `)}`,`fallback_exhausted`,{status:t?.status,cause:t,retryAfterMs:t?.retryAfterMs,code:`fallback_exhausted`,attempts:e}),this.attempts=e}get retryable(){let e=this.attempts[this.attempts.length-1]?.error;return e?e.retryable:super.retryable}};function S(e){return e instanceof x}async function C(e,t,n){if(!e.reserveUsage)return!1;try{return await e.reserveUsage({coalesced:t,signal:n}),!0}catch(e){throw n?.aborted?new f(`LLM request aborted`,`aborted`):new f(e instanceof Error?e.message:`Usage reservation failed`,`quota_exceeded`,{cause:e})}}function w(e,t,n,r){return async i=>{try{await e.refundUsage?.({coalesced:t,signal:n})}catch(e){r(i,e)}}}async function T(e,t,n,r,i){if(r?.aborted)throw new f(`LLM request aborted`,`aborted`);let a=await C(e,t,r),o=w(e,t,r,i);if(r?.aborted)throw a&&await o(`[VernLLM] refundUsage failed after abort`),new f(`LLM request aborted`,`aborted`);let s;try{s=await n()}catch(e){throw a&&await o(`[VernLLM] refundUsage failed`),e}if(r?.aborted)throw a&&await o(`[VernLLM] refundUsage failed after abort`),new f(`LLM request aborted`,`aborted`);return s}async function E(e,t,n,r){if(n?.aborted)throw new f(`LLM request aborted`,`aborted`);let i=await C(e,!1,n),a=w(e,!1,n,r);if(n?.aborted)throw i&&await a(`[VernLLM] refundUsage failed after abort`),new f(`LLM request aborted`,`aborted`);let o;try{o=await t()}catch(e){throw i&&await a(`[VernLLM] refundUsage failed after stream-open failure`),e}let s=o.finalResult.then(e=>e,async e=>{throw i&&await a(`[VernLLM] refundUsage failed after stream error`),e});return s.catch(()=>{}),{chunks:o.chunks,finalResult:s}}function D(e){return typeof e==`string`?e:JSON.stringify(e)??``}function ee(e,t){let n=[];if(t){let t=e;t.type===`tool_calls`?(t.toolCalls.forEach((e,t)=>{n.push({type:`tool_call_delta`,index:t,id:e.id,name:e.name,argsDelta:JSON.stringify(e.arguments??{}),complete:!0})}),t.content&&n.push({type:`text-delta`,delta:t.content})):n.push({type:`text-delta`,delta:D(t.content)})}else n.push({type:`text-delta`,delta:D(e)});return{async*[Symbol.asyncIterator](){for(let e of n)yield e}}}function te(e,t){return{async*[Symbol.asyncIterator](){let n=await e;yield*ee(n,t)}}}var ne=class{inFlight=new Map;constructor(e,t){this.cache=e,this.logger=t}async resolveCacheKey(e){return this.cache.resolveKey?await this.cache.resolveKey(e):e}async deleteCache(e){if(this.cache.delete)try{await this.cache.delete(await this.resolveCacheKey(e))}catch(e){this.logger.warn(`[VernLLM] cache delete failed: ${e instanceof Error?e.message:`unknown`}`)}}logRefundError(e,t){this.logger.error(e,{message:t instanceof Error?t.message:`unknown`})}async getCached(e){try{return await this.cache.get(e)}catch(e){return this.logger.warn(`[VernLLM] cache read failed: ${e instanceof Error?e.message:`unknown`}`),{hit:!1}}}async runCached(e){let t=await this.resolveCacheKey(e.cacheKey),n=t===e.cacheKey?e:{...e,cacheKey:t},r=await this.getCached(t);if(r.hit)return r.value;let i=this.inFlight.get(t);return i?T(n,!0,()=>i,e.signal,(e,t)=>this.logRefundError(e,t)):this.registerTrigger(n)}registerTrigger(e){let t=T(e,!1,()=>this.runAndCache(e),e.signal,(e,t)=>this.logRefundError(e,t));return this.inFlight.set(e.cacheKey,t),t.catch(()=>{}).finally(()=>{this.inFlight.delete(e.cacheKey)}),t}async runAndCache(e){let t=await e.fn();try{await this.cache.set(e.cacheKey,t,e.ttl)}catch(e){this.logger.warn(`[VernLLM] cache write failed: ${e instanceof Error?e.message:`unknown`}`)}return t}async runCachedStream(e,t){let n=await this.resolveCacheKey(e.cacheKey),r=n===e.cacheKey?e:{...e,cacheKey:n},i=await this.getCached(n);if(i.hit){let e=i.value;return{chunks:ee(e,t),finalResult:Promise.resolve(e)}}let a=this.inFlight.get(n);if(a){let n=T(r,!0,()=>a,e.signal,(e,t)=>this.logRefundError(e,t));return n.catch(()=>{}),{chunks:te(n,t),finalResult:n}}return this.registerStreamTrigger(r)}registerStreamTrigger(e){let t,n,r=new Promise((e,r)=>{t=e,n=r});this.inFlight.set(e.cacheKey,r),r.catch(()=>{}).finally(()=>{this.inFlight.delete(e.cacheKey)});let i=E(e,async()=>{let t=await e.openStream(),n=t.finalResult.then(async t=>{try{await this.cache.set(e.cacheKey,t,e.ttl)}catch(e){this.logger.warn(`[VernLLM] cache write failed: ${e instanceof Error?e.message:`unknown`}`)}return t},e=>{throw e});return{chunks:t.chunks,finalResult:n}},e.signal,(e,t)=>this.logRefundError(e,t));return i.then(e=>{e.finalResult.then(t,n)},e=>{n(e)}),i}};function re(){return{state:`closed`,consecutiveFailures:0,openedAt:0,trialInFlight:!1}}const O=``;var k=class{threshold;cooldownMs;onStateChange;isolateByModel;sharedBucket=re();bucketsByModel=new Map;constructor(e={}){this.threshold=e.threshold??5,this.cooldownMs=e.cooldownMs??3e4,this.onStateChange=e.onStateChange,this.isolateByModel=e.isolateByModel??!1}lookupBucket(e){if(!this.isolateByModel)return this.sharedBucket;let t=e??O;return this.bucketsByModel.get(t)}ensureBucketFor(e){if(!this.isolateByModel)return this.sharedBucket;let t=e??O,n=this.bucketsByModel.get(t);return n||(n=re(),this.bucketsByModel.set(t,n)),n}transition(e,t,n){if(t===e.state)return;let r=e.state;e.state=t,this.onStateChange?.(r,t,e.consecutiveFailures,n)}assertClosed(e){let t=this.ensureBucketFor(e);if(t.state!==`closed`){if(t.state===`open`){let n=Date.now()-t.openedAt;if(n<this.cooldownMs)throw new f(`Circuit open, provider has failed ${t.consecutiveFailures} times in a row. Retry in ${Math.ceil((this.cooldownMs-n)/1e3)}s.`,`circuit_open`,{code:`circuit_cooling_down`});t.trialInFlight=!0,this.transition(t,`half-open`,e);return}if(t.trialInFlight)throw new f(`Circuit half-open. A trial request is already in flight. Try again shortly.`,`circuit_open`,{code:`circuit_trial_in_flight`});t.trialInFlight=!0}}recordSuccess(e){let t=this.lookupBucket(e);t&&(t.consecutiveFailures=0,t.trialInFlight=!1,this.transition(t,`closed`,e),this.isolateByModel&&t.state===`closed`&&t.consecutiveFailures===0&&this.bucketsByModel.delete(e??O))}recordFailure(e){let t=this.ensureBucketFor(e);if(t.consecutiveFailures+=1,t.trialInFlight=!1,t.state===`half-open`){t.openedAt=Date.now(),this.transition(t,`open`,e);return}t.consecutiveFailures>=this.threshold&&(t.openedAt=Date.now(),this.transition(t,`open`,e))}getState(e){return this.lookupBucket(e)?.state??`closed`}open(e){let t=this.ensureBucketFor(e);t.openedAt=Date.now(),t.trialInFlight=!1,this.transition(t,`open`,e)}close(e){let t=this.ensureBucketFor(e);t.consecutiveFailures=0,t.trialInFlight=!1,this.transition(t,`closed`,e),this.isolateByModel&&t.state===`closed`&&t.consecutiveFailures===0&&this.bucketsByModel.delete(e??O)}};function A(e,t){return n=>{if(e)try{e(n)}catch(e){t.error(`[VernLLM] onEvent failed`,{message:e instanceof Error?e.message:`unknown`})}}}function ie(e,t,n,r,i){if(!e)return;let a=typeof e==`object`?e:void 0,o=a?.onStateChange,s=A(r,i);return new k({...a,onStateChange:(e,r,a,c)=>{if(s({kind:`circuit_state`,provider:t,model:c??n,from:e,to:r,consecutiveFailures:a}),o)try{o(e,r,a,c)}catch(e){i.error(`[VernLLM] circuitBreaker.onStateChange failed`,{message:e instanceof Error?e.message:`unknown`})}}})}const j=1e4,ae=2147483647;function M(e){return!e||e<=0||e===1/0?void 0:e}function N(e){return Math.min(e,ae)}async function oe(e,t,n){let r=new AbortController,i=M(t),a=i===void 0?void 0:setTimeout(()=>{r.abort()},N(i)),o=n?AbortSignal.any([n,r.signal]):r.signal;try{return await e(o)}catch(e){throw r.signal.aborted&&!n?.aborted&&e instanceof DOMException&&e.name===`AbortError`?new f(`Request timed out`,`timeout`,{code:`request_timeout`}):e}finally{clearTimeout(a)}}function se(e,t,n,r){let i=M(t);if(i===void 0)return e();let a=!1;return new Promise((t,o)=>{let s=setTimeout(()=>{a=!0,n?.(),o(new f(`No stream chunk received for ${i}ms (idle timeout)`,`timeout`,{code:`idle_timeout`}))},N(i));e().then(e=>{if(clearTimeout(s),a){r?.debug(`[VernLLM] chunk resolved after idle timeout already fired; discarding`);return}a=!0,t(e)},e=>{if(clearTimeout(s),a){r?.debug(`[VernLLM] chunk rejection arrived after idle timeout already fired; discarding`);return}a=!0,o(e)})})}function ce(e,t=j){if(!e||typeof e!=`object`)return;let n=e,r=n.headers??n.response?.headers;if(!r||typeof r!=`object`)return;let i=r,a=typeof i.get==`function`?i.get(`Retry-After`):Object.entries(r).find(([e])=>e.toLowerCase()===`retry-after`)?.at(1);if(typeof a!=`string`||a.trim()===``)return;let o=a.trim();if(/^\d+$/.test(o))return Math.max(0,Math.min(Number(o)*1e3,t));let s=Date.parse(o);if(!Number.isNaN(s))return Math.max(0,Math.min(s-Date.now(),t))}function le(e,t,n=j){let r=Math.min(e*2**t,n);return r/2+Math.random()*(r/2)}async function ue(e,t){if(t?.aborted)throw new f(`Operation aborted`,`aborted`);await new Promise((n,r)=>{let i=()=>{clearTimeout(a),r(new f(`Operation aborted`,`aborted`))},a=setTimeout(()=>{t?.removeEventListener(`abort`,i),n()},e);t?.addEventListener(`abort`,i,{once:!0})})}function de(e){if(!e||typeof e!=`object`)return;let t=e;if(typeof t.status==`number`)return t.status;if(typeof t.statusCode==`number`)return t.statusCode;if(typeof t.$metadata?.httpStatusCode==`number`)return t.$metadata.httpStatusCode}const fe=new Set([`ECONNREFUSED`,`ENOTFOUND`,`ECONNRESET`,`ETIMEDOUT`,`EAI_AGAIN`,`EPIPE`,`ECONNABORTED`,`EHOSTUNREACH`,`ENETUNREACH`]),pe=new Set([`fetch failed`,`failed to fetch`,`load failed`,`networkerror when attempting to fetch resource.`]);function me(e){if(!e||typeof e!=`object`)return!1;let t=e;if(typeof t.code==`string`&&fe.has(t.code)||typeof t.message==`string`&&pe.has(t.message.toLowerCase()))return!0;if(t.cause&&typeof t.cause==`object`){let e=t.cause;if(typeof e.code==`string`&&fe.has(e.code))return!0}return!1}function he(e){try{return JSON.stringify(e,null,2)??String(e)}catch{try{return String(e)}catch{return`[unprintable error]`}}}function P(e){if(e&&typeof e==`object`)try{let t=e;if(t.error!==void 0)return he(t.error);if(typeof t.message==`string`)return t.message}catch{}return he(e)}function ge(e){switch(e){case 429:return`provider_rate_limited`;case 401:return`authentication`;case 403:return`authorization`;case 404:return`not_found`;case 413:return`payload_too_large`;default:return e>=500?`server_error`:void 0}}const _e=/\(no body\)/i;function ve(e){return Object.keys(e).length===0}function ye(e){if(e&&typeof e==`object`){let{error:t,message:n}=e;if(t!=null){let e=typeof t==`string`&&t.trim().length===0,n=typeof t==`object`&&ve(t);if(!e&&!n)return!1}if(typeof n==`string`){let e=n.trim();return e.length===0||_e.test(e)}return!0}return!0}function F(e,t,n){if(t?.aborted)return new f(`LLM request aborted`,`aborted`,{attempts:n});if(e instanceof f)return e.code===void 0&&e.status!==void 0&&(e.code=ge(e.status)),e.attempts===void 0&&n!==void 0&&(e.attempts=n),e;let r=de(e),i=ce(e);if(r!==void 0){let t=P(e),a=ge(r),o=a===void 0,s=ye(e)?o?`LLM request failed with status ${r} 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 ${r} and no error detail from the provider.`:`LLM request failed: ${t}`;return new f(s,`api`,{status:r,cause:e,retryAfterMs:i,code:a,attempts:n})}return me(e)?new f(`LLM request failed`,`network`,{cause:e,retryAfterMs:i,code:`connection_failed`,attempts:n}):new f(`LLM request failed`,`unknown`,{cause:e,retryAfterMs:i,attempts:n})}function be(e){try{return JSON.parse(e)}catch{return}}function xe(e){return e.map(e=>({type:`function`,function:{name:e.name,description:e.description,parameters:e.parameters}}))}function Se(e){return e.map(e=>({id:e.id,type:`function`,function:{name:e.name,arguments:JSON.stringify(e.arguments??{})}}))}function Ce(e){return e.map(e=>{let t;try{t=e.function.arguments.trim()?JSON.parse(e.function.arguments):{}}catch{throw new f(`Invalid JSON arguments for tool call "${e.function.name}"`,`parse`,{code:`tool_arguments_parse_failed`})}return{id:e.id,name:e.function.name,arguments:t}})}function we(e){return typeof e==`string`?e:JSON.stringify(e)}var Te=class{model;defaultMaxTokens;defaultTemperature;defaultReasoningEffort;defaultBudgetTokens;supportsJsonObjectMode;constructor(e){this.model=e.model,this.defaultMaxTokens=e.defaultMaxTokens,this.defaultTemperature=e.defaultTemperature,this.defaultReasoningEffort=e.defaultReasoningEffort,this.defaultBudgetTokens=e.defaultBudgetTokens,this.supportsJsonObjectMode=e.supportsJsonObjectMode}build(e){let{systemPrompt:t,userContent:n,history:r=[],maxTokens:i=this.defaultMaxTokens,model:a=this.model,jsonSchema:o,tools:s,toolChoice:c}=e,l=e.temperature===void 0?this.defaultTemperature:e.temperature,u=e.reasoningEffort===void 0?this.defaultReasoningEffort:e.reasoningEffort,d=e.budgetTokens===void 0?this.defaultBudgetTokens:e.budgetTokens;if(s&&s.length===0)throw new f("`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(s){let e=new Set,t=new Set;for(let n of s)e.has(n.name)&&t.add(n.name),e.add(n.name);if(t.size)throw new f(`\`tools\` has duplicate name(s): [${[...t].join(`, `)}]. Tool names must be unique.`,`invalid_params`,{code:`duplicate_tool_names`,issues:{names:[...t]}})}if(c&&!s)throw new f("`toolChoice` was set without `tools`. There is nothing for it to choose between. Set `tools`, or remove `toolChoice`.",`invalid_params`);if(s&&typeof c==`object`&&!s.some(e=>e.name===c.name))throw new f(`toolChoice names "${c.name}", which is not in \`tools\` ([${s.map(e=>e.name).join(`, `)}]).`,`invalid_params`,{code:`unknown_tool_choice`,issues:{requested:c.name,available:s.map(e=>e.name)}});let p=e.jsonMode,m=p??!s;if(!this.supportsJsonObjectMode&&!o&&p===!0)throw new f('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&&!o&&p===void 0&&e.schema)throw new f('`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`);let h=!this.supportsJsonObjectMode&&!o&&p===void 0?!1:m,g=h||!!o;if(e.schema&&!g)throw new f(`schema was provided but jsonMode: false disables JSON parsing, so nothing would validate it. Remove jsonMode: false, set jsonSchema, or remove schema.`,`invalid_params`);let _=this.buildResponseFormat(o,g);this.validateHistory(r);let v={model:a,...l===null?{}:{temperature:l},max_tokens:i,..._?{response_format:_}:{},...u?{reasoning_effort:u}:{},...d==null?{}:{budget_tokens:d},...s?{tools:xe(s)}:{},...s?{tool_choice:this.buildWireToolChoice(c)}:{},messages:[...t?[{role:`system`,content:t}]:[],...r.flatMap(e=>this.turnToWireMessages(e)),{role:`user`,content:n}]};return{useJson:g,model:a,request:v}}validateHistory(e){let t;for(let[n,r]of e.entries()){if(r.role===`tool`){if(t?.role!==`assistant`||!t.toolCalls?.length)throw new f(`history[${n}] is a "tool" turn, but must immediately follow an "assistant" turn that requested tools`,`invalid_params`);if(!r.toolResults?.length)throw new f(`history[${n}] is a "tool" turn but has no toolResults`,`invalid_params`);let e=new Set(t.toolCalls.map(e=>e.id)),i=r.toolResults.map(e=>e.toolCallId),a=i.filter(t=>!e.has(t));if(a.length)throw new f(`history[${n}].toolResults references unknown toolCallId(s) [${a.join(`, `)}]`,`invalid_params`,{code:`unknown_tool_result_ids`,issues:{historyIndex:n,ids:a}});let o=new Set,s=new Set;for(let e of i)o.has(e)&&s.add(e),o.add(e);if(s.size)throw new f(`history[${n}].toolResults has duplicate toolCallId(s) [${[...s].join(`, `)}]`,`invalid_params`,{code:`duplicate_tool_result_ids`,issues:{historyIndex:n,ids:[...s]}});let c=[...e].filter(e=>!i.includes(e));if(c.length)throw new f(`history[${n}] is missing toolResults for toolCallId(s) [${c.join(`, `)}]`,`invalid_params`,{code:`missing_tool_results`,issues:{historyIndex:n,ids:c}})}else{if(r.role===t?.role)throw new f(`history must alternate user/assistant turns: consecutive "${r.role}" turns at history[${n-1}] and history[${n}]`,`invalid_params`);if(t?.role===`assistant`&&t.toolCalls?.length)throw new f(`history[${n}] follows an assistant tool request without tool results`,`invalid_params`)}t=r}if(t?.role===`assistant`&&t.toolCalls?.length)throw new f(`The last entry in history is an assistant tool request without tool results`,`invalid_params`);if(t?.role===`user`)throw new f(`The last entry in history is a "user" turn, which would collide with the current userContent turn.`,`invalid_params`)}buildWireToolChoice(e){return!e||e===`auto`?`auto`:e===`none`||e===`required`?e:{type:`function`,function:{name:e.name}}}turnToWireMessages(e){return e.role===`tool`?(e.toolResults??[]).map(e=>({role:`tool`,tool_call_id:e.toolCallId,content:typeof e.content==`string`?e.content:JSON.stringify(e.content??null),...e.isError?{is_error:!0}:{}})):e.role===`assistant`&&e.toolCalls?.length?[{role:`assistant`,...e.content===void 0?{}:{content:we(e.content)},tool_calls:Se(e.toolCalls)}]:e.role===`assistant`?[{role:`assistant`,content:we(e.content===void 0?``:e.content)}]:[{role:e.role,content:e.content??``}]}buildResponseFormat(e,t){return e?{type:`json_schema`,json_schema:{name:e.name,schema:e.schema,strict:e.strict??!0,description:e.description}}:t?{type:`json_object`}:void 0}};function Ee(e,t,n){let{requestId:r,model:i,providerName:a,isFallback:o,chunkIdleTimeoutMs:s,streamController:c,logger:l,signal:u}=n,d,f,p=new Promise((e,t)=>{d=e,f=t});p.catch(()=>{});let m=1e4,h=[],g=[],_=!1,v,y=!1,b=e=>{let t=g.shift();if(t){t.resolve({done:!1,value:e});return}h.push(e),h.length>m*2&&(y||(y=!0,l.warn(`[VernLLM] stream chunk buffer exceeded cap (${m}), evicting ${h.length-m} oldest chunk(s); buffered=${h.length}. The chunks iterable was never read (or fell far behind) for this stream.`)),h.splice(0,h.length-m))},x=()=>{_=!0;for(let e of g.splice(0))e.resolve({done:!0,value:void 0})},S=e=>{_=!0,v=e;for(let t of g.splice(0))t.reject(e)},C={[Symbol.asyncIterator](){return{next(){return h.length?Promise.resolve({done:!1,value:h.shift()}):_?v?Promise.reject(v):Promise.resolve({done:!0,value:void 0}):new Promise((e,t)=>{g.push({resolve:e,reject:t})})}}}},w=new Map,T=``,E;return(async()=>{try{let n=t;for(;!n.done;){let t=n.value;if(t.type!==`ping`){if(t.type===`text-delta`)T+=t.delta,b({type:`text-delta`,delta:t.delta});else if(t.type===`tool_call_delta`){let e=w.get(t.index)??{args:``};e.id??=t.id,e.name??=t.name,e.args+=t.argumentsDelta??``,w.set(t.index,e),b({type:`tool_call_delta`,index:t.index,id:t.id,name:t.name,argsDelta:t.argumentsDelta,complete:t.complete})}else if(t.type===`usage`){let e=t.usage.completion_tokens_details?.reasoning_tokens;E={promptTokens:t.usage.prompt_tokens??0,completionTokens:t.usage.completion_tokens??0,totalTokens:t.usage.total_tokens??0,...e===void 0?{}:{reasoningTokens:e},requestId:r,model:i,provider:a,usedFallback:o},b({type:`usage`,usage:E})}}n=await se(()=>e.next(),s,()=>c.abort(),l)}}catch(t){try{await e.return?.()}catch{}c.abort();let r=F(t,u);try{n.onStreamFailure(r,E)}catch{}S(r),f(r);return}x();try{n.onStreamSuccess(E)}catch{}try{let e=w.size?[...w.entries()].sort(([e],[t])=>e-t).map(([,e])=>({id:e.id??``,type:`function`,function:{name:e.name??``,arguments:e.args}})):void 0,t=n.finalize(T,e,E);d(t)}catch(e){f(e)}})(),{chunks:C,finalResult:p}}function De(e){return e}var Oe=class{maxRetries;timeoutMs;chunkIdleTimeoutMs;baseDelayMs;nonRetryableStatus;parseJson;logger;redact;onUsage;onUsageFailure;reportEvent;breaker;limiter;isFallback;requestBuilder;constructor(e,t,n,r){this.providerName=e,this.client=t,this.model=n,this.maxRetries=r.maxRetries,this.timeoutMs=r.timeoutMs,this.chunkIdleTimeoutMs=r.chunkIdleTimeoutMs,this.baseDelayMs=r.baseDelayMs,this.nonRetryableStatus=r.nonRetryableStatus,this.parseJson=r.parseJson??be,this.logger=r.logger,this.redact=r.redact,this.onUsage=r.onUsage,this.onUsageFailure=r.onUsageFailure,this.reportEvent=A(r.onEvent,this.logger),this.breaker=r.breaker,this.limiter=r.limiter,this.isFallback=r.isFallback??!1,this.requestBuilder=new Te({model:n,defaultMaxTokens:r.defaultMaxTokens,defaultTemperature:r.defaultTemperature,defaultReasoningEffort:r.defaultReasoningEffort,defaultBudgetTokens:r.defaultBudgetTokens,supportsJsonObjectMode:t.supportsJsonObjectMode??!0})}getCircuitState(e){return this.breaker?.getState(e)}get isolateByModel(){return this.breaker?.isolateByModel??!1}openCircuit(e){this.breaker?.open(e)}closeCircuit(e){this.breaker?.close(e)}assertBreakerClosed(e){this.breaker?.assertClosed(e??this.model)}async run(e,t,n){let r=e.model??this.model,i=[];try{return await this.retryWithBackoff((n,r)=>this.executeCall(e,t,n,r),t,r,e.signal,n,i)}catch(n){let a=F(n,e.signal,i.length>0?i:void 0);throw this.countsTowardBreaker(a)&&this.breaker?.recordFailure(r),this.logger.debug(`[VernLLM:${t}] error:\n${this.redactText(P(n))}`),a}}async runStream(e,t,n){let r=e.model??this.model,i=[];try{return await this.retryWithBackoff((n,r)=>this.executeStreamCall(e,t,n,r),t,r,e.signal,n,i)}catch(n){let a=F(n,e.signal,i.length>0?i:void 0);throw this.countsTowardBreaker(a)&&this.breaker?.recordFailure(r),this.logger.debug(`[VernLLM:${t}] stream-open error:\n${this.redactText(P(n))}`),a}}async executeCall(e,t,n,r){let{useJson:i,model:a,request:o}=this.requestBuilder.build(e);r?.(d(this.providerName,a,o,void 0,Date.now()));let s;if(this.limiter){let n=await this.limiter.acquire(this.limiter.estimate(o),e.signal);s=n.release,n.waitedMs>0&&this.reportEvent({kind:`rate_limited`,requestId:t,provider:this.providerName,model:a,waitedMs:n.waitedMs,reason:n.reason??`rpm`})}try{let r=await oe(e=>this.client.chat.completions.create(o,{signal:e}),this.timeoutMs,e.signal),c=this.extractUsage(r,t,a);s?.(this.actualTokensFor(c)),s=void 0;let l=r.choices?.[0]?.message?.content,u=r.choices?.[0]?.message?.tool_calls;return this.finalizeResponse(l,u,e,i,a,c,t,n)}finally{s?.()}}redactText(e){return this.redact?this.redact(e):e}redactedOutput(e,t){return this.redactText(e??`[${t?.length??0} tool call(s)]`)}finalizeResponse(e,t,n,r,i,a,o,s){try{let s=e?.trim();if(!s&&!t?.length)throw new f(`Empty LLM response`,`api`,{code:`empty_response`});if(this.logger.debug(`[VernLLM:${o}] output:\n${this.redactedOutput(s,t).slice(0,800)}`),t?.length){if(!n.tools)throw new f("Provider returned tool_calls but no `tools` were sent with this call.",`validation`,{code:`unexpected_tool_calls`});if(n.toolChoice===`none`)throw new f(`Provider returned tool_calls despite toolChoice: 'none'.`,`validation`,{code:`tool_choice_none_violated`});let e=Ce(t);return this.validateToolCallArguments(e,n.tools),this.breaker?.recordSuccess(i),this.reportUsage(a),{type:`tool_calls`,toolCalls:e,...s?{content:s}:{}}}let c=s??``;if(!r)return this.breaker?.recordSuccess(i),this.reportUsage(a),n.tools?{type:`content`,content:c}:c;let l=this.parseAndValidate(c,n.schema);return this.breaker?.recordSuccess(i),this.reportUsage(a),n.tools?{type:`content`,content:l}:l}catch(e){let t=F(e,n.signal);throw a&&t.type!==`aborted`&&this.reportUsageFailure(a,t,s),t}}async executeStreamCall(e,t,n,r){let{useJson:i,model:a,request:o}=this.requestBuilder.build(e);r?.(d(this.providerName,a,o,void 0,Date.now()));let s=this.client.chat.completions;if(!s.createStream)throw new f(`stream: true requires a client/adapter with createStream`,`invalid_params`,{code:`unsupported_capability`,issues:{capability:`createStream`}});let c=s.createStream.bind(s),l;if(this.limiter){let n=await this.limiter.acquire(this.limiter.estimate(o),e.signal);l=n.release,n.waitedMs>0&&this.reportEvent({kind:`rate_limited`,requestId:t,provider:this.providerName,model:a,waitedMs:n.waitedMs,reason:n.reason??`rpm`})}let u=new AbortController,p=e.signal?AbortSignal.any([e.signal,u.signal]):u.signal;try{let{iterator:r,first:s}=await oe(async e=>{let t=c(o,{signal:e})[Symbol.asyncIterator](),n=await t.next();return{iterator:t,first:n}},this.timeoutMs,p);if(s.done)throw new f(`Empty LLM response`,`api`);let d=l,m=Ee(r,s,{requestId:t,model:a,providerName:this.providerName,isFallback:this.isFallback,chunkIdleTimeoutMs:e.chunkIdleTimeoutMs??this.chunkIdleTimeoutMs,streamController:u,logger:this.logger,signal:e.signal,onStreamSuccess:e=>{this.breaker?.recordSuccess(a),d?.(this.actualTokensFor(e))},onStreamFailure:(e,t)=>{e.type===`timeout`&&this.breaker?.recordFailure(a),t&&e.type!==`aborted`&&this.reportUsageFailure(t,e,n,!0),d?.(this.actualTokensFor(t))},finalize:(r,o,s)=>this.finalizeResponse(r,o,e,i,a,s,t,n)});return l=void 0,m}finally{l?.()}}validateToolCallArguments(e,t){let n=new Map(t.map(e=>[e.name,e])),r=new Set,i=[];for(let t of e)r.has(t.id)&&i.push({name:t.name,toolCallId:t.id,code:`duplicate_tool_call_id`}),r.add(t.id),n.has(t.name)||i.push({name:t.name,toolCallId:t.id,code:`unknown_tool`});if(i.length>0){let e=i.find(e=>e.code===`unknown_tool`),t=e?`Model requested tool "${e.name}", which was not in the tools offered ([${[...n.keys()].join(`, `)}]).`:`Duplicate tool call id "${i[0].toolCallId}" in the model's response.`,r=i.length>1?`${t} (${i.length} tool call issues total, see error.issues.)`:t;throw new f(r,`validation`,{code:e?`unknown_tool`:`duplicate_tool_call_id`,issues:i})}for(let t of e){let e=n.get(t.name);if(!e?.argumentsSchema)continue;let r=e.argumentsSchema.safeParse(t.arguments);if(!r.success)throw new f(`Arguments for tool call "${t.name}" failed validation`,`validation`,{issues:r.error})}}async retryWithBackoff(e,t,n,r,i,a){let o,s;for(let c=0;c<=this.maxRetries;c++){s=void 0;try{return c>0&&await this.recoverDelay(t,n,c,o,r),i?.(),await e(c,e=>{s=e})}catch(e){o=e;let t=c<this.maxRetries&&this.shouldRetry(e,r);if(!t)break;a?.push({index:c,error:F(e,r).toSnapshot(),request:De(s)})}}throw o}extractUsage(e,t,n){if(!e.usage)return;let r=e.usage.completion_tokens_details?.reasoning_tokens;return{promptTokens:e.usage.prompt_tokens??0,completionTokens:e.usage.completion_tokens??0,totalTokens:e.usage.total_tokens??0,...r===void 0?{}:{reasoningTokens:r},requestId:t,model:n,provider:this.providerName,usedFallback:this.isFallback}}actualTokensFor(e){if(e)return e.totalTokens||e.promptTokens+e.completionTokens}reportUsage(e){if(!(!e||!this.onUsage))try{this.onUsage(e)}catch(e){this.logger.error(`[VernLLM] onUsage failed`,{message:e instanceof Error?e.message:`unknown`})}}reportUsageFailure(e,t,n,r=!1){let i=e.totalTokens||e.promptTokens+e.completionTokens,a=r?`mid-stream failure (terminal, no further attempts)`:`attempt ${n+1}/${this.maxRetries+1}`;if(this.logger.warn(`[VernLLM:${e.requestId}] usage failure, ${a}: type=${t.type} tokens=${i}`),this.onUsageFailure)try{this.onUsageFailure(e,t)}catch(e){this.logger.error(`[VernLLM] onUsageFailure failed`,{message:e instanceof Error?e.message:`unknown`})}}parseAndValidate(e,t){let n;try{n=this.parseJson(e)}catch{throw new f(`Invalid JSON response`,`parse`)}if(n==null)throw new f(`Invalid JSON response`,`parse`);if(!t)return n;let r=t.safeParse(n);if(!r.success)throw new f(`Schema validation failed`,`validation`,{issues:r.error});return r.data}async recoverDelay(e,t,n,r,i){let a=ce(r),o=a??le(this.baseDelayMs,n),s=a!==void 0;this.logger.warn(`[VernLLM:${e}] recovery attempt ${n}/${this.maxRetries}, waiting ${Math.ceil(o)}ms`+(s?` (honoring Retry-After)`:``)),this.reportEvent({kind:`retry`,requestId:e,provider:this.providerName,model:t,attempt:n,maxRetries:this.maxRetries,delayMs:o,retryAfterHonored:s,error:F(r,i)}),await ue(o,i)}shouldRetry(e,t){if(t?.aborted||e instanceof f&&!e.retryable)return!1;let n=de(e);return!(n!==void 0&&this.nonRetryableStatus.includes(n))}countsTowardBreaker(e){return e.retryable}};function ke(e){return{debug:I(e,`debug`),warn:I(e,`warn`),error:I(e,`error`)}}function I(e,t){let n=e[t].bind(e);return(...e)=>{try{je(n(...e))}catch{}}}function Ae(e){return typeof e?.then==`function`}function je(e){Ae(e)&&Promise.resolve(e).catch(()=>{})}var L=class{constructor(e){this.debugEnabled=e}debug(e){this.debugEnabled&&console.debug(e)}warn(e){console.warn(e)}error(e,t){console.error(e,t??``)}};function R(e){let t=e.messages.reduce((e,t)=>{let n=t.content;if(typeof n==`string`)return e+n.length;if(n==null)return e;try{return e+JSON.stringify(n).length}catch{return e}},0);return Math.ceil(t/4)+(e.max_tokens??0)}var z=class{available;lastRefill=Date.now();constructor(e,t){this.capacity=e,this.refillPerMs=t,this.available=e}refill(){if(this.refillPerMs===0)return;let e=Date.now(),t=e-this.lastRefill;this.available=Math.min(this.capacity,this.available+Math.max(0,t)*this.refillPerMs),this.lastRefill=e}tryTake(e){return this.refill(),this.available<e?!1:(this.available-=e,!0)}msUntilAvailable(e){return this.refill(),this.available>=e?0:this.refillPerMs===0?1/0:(e-this.available)/this.refillPerMs}give(e){this.available=Math.min(this.capacity,this.available+e)}getCapacity(){return this.capacity}};const Me=2147483647;var B=class{requests;tokens;concurrency;maxQueueMs;maxQueueSize;estimateTokensFn;queue=[];wakeTimer;constructor(e){e.requestsPerMinute&&(this.requests=new z(e.requestsPerMinute,e.requestsPerMinute/6e4)),e.tokensPerMinute&&(this.tokens=new z(e.tokensPerMinute,e.tokensPerMinute/6e4)),e.maxConcurrent&&(this.concurrency=new z(e.maxConcurrent,0)),this.maxQueueMs=e.maxQueueMs??3e4,this.maxQueueSize=e.maxQueueSize??0,this.estimateTokensFn=e.estimateTokens??R}estimate(e){return this.estimateTokensFn(e)}async acquire(e,t){if(t?.aborted)throw new f(`LLM request aborted`,`aborted`);if(!Number.isFinite(e)||e<0)throw new f(`estimatedTokens must be a finite, non-negative number, got ${String(e)}`,`invalid_params`);if(this.tokens&&e>this.tokens.getCapacity())throw new f(`estimatedTokens (${e}) exceeds the configured tokensPerMinute capacity (${this.tokens.getCapacity()}); this call could never acquire capacity.`,`rate_limited`,{code:`rate_limit_capacity_exceeded`});if(this.queue.length===0){let n=this.tryAcquireBuckets(e);return n.ok?{release:this.makeRelease(e),waitedMs:0}:this.enqueue(e,n.reason,t)}if(this.maxQueueSize>0&&this.queue.length>=this.maxQueueSize)throw this.queueFullError();return this.enqueue(e,void 0,t)}queueFullError(){return new f(`Rate limit queue is full`,`rate_limited`,{code:`rate_limit_queue_full`})}enqueue(e,t,n){return new Promise((r,i)=>{let a={estimatedTokens:e,enqueuedAt:Date.now(),lastReason:t,resolve:e=>{c(),r(e)},reject:e=>{c(),this.wakeTimer&&(clearTimeout(this.wakeTimer),this.wakeTimer=void 0),this.drain(),i(e)}},o,s=()=>{a.reject(new f(`LLM request aborted`,`aborted`))},c=()=>{o&&clearTimeout(o),n?.removeEventListener(`abort`,s);let e=this.queue.indexOf(a);e!==-1&&this.queue.splice(e,1)};this.maxQueueMs>0&&(o=setTimeout(()=>{a.reject(new f(`Rate limit queue timed out before capacity was available`,`rate_limited`,{code:`rate_limit_queue_timeout`}))},this.maxQueueMs)),n?.addEventListener(`abort`,s,{once:!0}),this.queue.push(a),this.drain()})}tryAcquireBuckets(e){let t=[],n=(e,n)=>e?e.tryTake(n)?(t.push({bucket:e,amount:n}),!0):!1:!0;if(!n(this.concurrency,1))return{ok:!1,reason:`concurrency`};if(!n(this.requests,1)){for(let e of t)e.bucket.give(e.amount);return{ok:!1,reason:`rpm`}}if(!n(this.tokens,e)){for(let e of t)e.bucket.give(e.amount);return{ok:!1,reason:`tpm`}}return{ok:!0}}drain(){for(;this.queue.length>0;){let e=this.queue[0],t=this.tryAcquireBuckets(e.estimatedTokens);if(!t.ok){e.lastReason=t.reason,this.scheduleWake(t.reason,e.estimatedTokens);return}let n=Date.now()-e.enqueuedAt;e.resolve({release:this.makeRelease(e.estimatedTokens),waitedMs:n,reason:e.lastReason})}}scheduleWake(e,t){if(this.wakeTimer)return;let n=e===`rpm`?this.requests?.msUntilAvailable(1):e===`tpm`?this.tokens?.msUntilAvailable(t):void 0;if(n===void 0||!Number.isFinite(n))return;let r=Math.min(Math.max(1,Math.ceil(n)),Me);this.wakeTimer=setTimeout(()=>{this.wakeTimer=void 0,this.drain()},r)}makeRelease(e){let t=!1;return n=>{t||(t=!0,this.concurrency?.give(1),this.tokens&&n!==void 0&&Number.isFinite(n)&&this.tokens.give(e-n),this.drain())}}},Ne=class{logger;executors;fallbackOn;reportEvent;cacheOrchestrator;constructor(e){this.logger=ke(e.logger??new L(e.debug??!1));let t=e.name??`primary`;this.cacheOrchestrator=new ne(e.cache??new h,this.logger),this.fallbackOn=e.fallbackOn??b,this.reportEvent=A(e.onEvent,this.logger);let n=e.defaultTemperature===void 0?.2:e.defaultTemperature,r=e.defaultReasoningEffort,i=e.defaultBudgetTokens,a={client:e.client,model:e.model,name:t,maxRetries:e.maxRetries,timeoutMs:e.timeoutMs,chunkIdleTimeoutMs:e.chunkIdleTimeoutMs,baseDelayMs:e.baseDelayMs,defaultMaxTokens:e.defaultMaxTokens,defaultTemperature:n,defaultReasoningEffort:r,defaultBudgetTokens:i,nonRetryableStatus:e.nonRetryableStatus,circuitBreaker:e.circuitBreaker,rateLimit:e.rateLimit},o=Array.isArray(e.fallback)?e.fallback:e.fallback?[e.fallback]:[],s=[a,...o];this.executors=s.map((a,o)=>{let s=o>0,c=a.name??(s?`fallback[${o-1}]`:t),l=ie(a.circuitBreaker,c,a.model,e.onEvent,this.logger);return new Oe(c,a.client,a.model,{maxRetries:a.maxRetries??e.maxRetries??1,timeoutMs:a.timeoutMs??e.timeoutMs??25e3,chunkIdleTimeoutMs:a.chunkIdleTimeoutMs??e.chunkIdleTimeoutMs??3e4,baseDelayMs:a.baseDelayMs??e.baseDelayMs??500,defaultMaxTokens:a.defaultMaxTokens??e.defaultMaxTokens??1e3,defaultTemperature:a.defaultTemperature===void 0?n:a.defaultTemperature,defaultReasoningEffort:a.defaultReasoningEffort===void 0?r:a.defaultReasoningEffort,defaultBudgetTokens:a.defaultBudgetTokens===void 0?i:a.defaultBudgetTokens,nonRetryableStatus:a.nonRetryableStatus??e.nonRetryableStatus??[400,401,403,404,422],parseJson:e.parseJson,logger:this.logger,redact:e.redact,onUsage:e.onUsage,onUsageFailure:e.onUsageFailure,onEvent:e.onEvent,breaker:l,limiter:a.rateLimit?new B(a.rateLimit):void 0,isFallback:s})})}logRefundError(e,t){this.logger.error(e,{message:t instanceof Error?t.message:`unknown`})}async runFallbackChain(e,t,n,r=!1){let i=[];for(let a=0;a<this.executors.length;a++){let o=this.executors[a],s=Date.now(),c=0;try{a===0&&r||o.assertBreakerClosed(e.model);let t=await n(o,()=>{c+=1});return{result:t,executor:o,index:a,attemptCount:c}}catch(n){let r=F(n,e.signal);i.push({index:a-1,provider:o.providerName,model:e.model??o.model,error:r.toSnapshot()});let c=a===this.executors.length-1,l=this.fallbackOn(r,{isLastTarget:c}),u=c?`stop`:l;if(u===`stop`)throw i.length>1?new x(i):r;let d=this.executors[a+1];this.reportEvent({kind:`fallback`,requestId:t,from:o.providerName,to:d.providerName,fromIndex:a-1,toIndex:a,error:r,elapsedMs:Date.now()-s})}}throw new f(`No provider targets configured`,`invalid_params`)}async call(t){if(t.signal?.aborted)throw new f(`LLM request aborted`,`aborted`);let n=t.requestId??e(),r=this.executors.length===1;return r&&this.executors[0].assertBreakerClosed(t.model),t.stream?E(t,async()=>{let{result:e}=await this.runFallbackChain(t,n,(e,r)=>e.runStream(t,n,r),r);return e},t.signal,(e,t)=>this.logRefundError(e,t)):T(t,!1,async()=>{let{result:e,executor:i,index:a,attemptCount:o}=await this.runFallbackChain(t,n,(e,r)=>e.run(t,n,r),r);return t.meta&&(t.meta.current={provider:i.providerName,model:t.model??i.model,fallbackIndex:a-1,usedFallback:a>0,attempts:o}),e},t.signal,(e,t)=>this.logRefundError(e,t))}runCached(e){return this.cacheOrchestrator.runCached(e)}async deleteCache(e){await this.cacheOrchestrator.deleteCache(e)}async cachedCall(e){let{call:t,...n}=e,r=t;if(r.reserveUsage||r.refundUsage)throw new f("`reserveUsage`/`refundUsage` were set inside `call`, where cachedCall ignores them. Move them to the top level of the cachedCall() params, alongside cacheKey/ttl, instead.",`invalid_params`);if(r.stream){let e=r;return this.cacheOrchestrator.runCachedStream({...n,openStream:()=>this.call(e)},!!r.tools)}return this.runCached({...n,fn:()=>this.call(r)})}getCircuitState(e){let t=this.resolveExecutor(e?.index??0,`getCircuitState`);return this.warnIfModelUnsupported(t.isolateByModel,e?.model,`getCircuitState`),t.getCircuitState(e?.model??t.model)}getCircuitStates(e){return this.executors.map((t,n)=>({provider:t.providerName,index:n,isFallback:n>0,isolateByModel:t.isolateByModel,state:t.getCircuitState(e??t.model)}))}openCircuit(e){let t=this.resolveExecutor(e?.index??0,`openCircuit`);this.warnIfModelUnsupported(t.isolateByModel,e?.model,`openCircuit`),t.openCircuit(e?.model??t.model)}closeCircuit(e){let t=this.resolveExecutor(e?.index??0,`closeCircuit`);this.warnIfModelUnsupported(t.isolateByModel,e?.model,`closeCircuit`),t.closeCircuit(e?.model??t.model)}resolveExecutor(e,t){let n=this.executors[e];if(!n)throw RangeError(`${t}: no target at index ${e} (chain has ${this.executors.length} target${this.executors.length===1?``:`s`})`);return n}warnIfModelUnsupported(e,t,n){t!==void 0&&!e&&this.logger.warn(`[VernLLM] ${n}: \`model: '${t}'\` 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.`)}};function Pe(e){return e}function Fe(e){return e}async function*V(e){let t=new TextDecoder(`utf-8`,{fatal:!0}),n=``;for await(let r of e){let e;try{e=typeof r==`string`?r:t.decode(r,{stream:!0})}catch(e){throw new f(`Invalid UTF-8 in SSE stream`,`parse`,{cause:e})}n=(n+e).replace(/\r\n/g,`
+`).replace(/\r(?!$)/g,`
+`);let i=n.indexOf(`
 
-//#region src/types/errors.ts
-/**
-* Tool contract codes: a model or provider response defect, not a
-* transient provider fault. Deterministic on the wire request, so
-* retrying can't change the outcome and it shouldn't count toward the
-* circuit breaker either. Shared by `LLMError.retryable` below and by
-* `CallExecutor`'s own retry/breaker accounting, so the two can't drift
-* apart.
-*/
-const NON_RETRYABLE_TOOL_CONTRACT_CODES = new Set([
-	"unknown_tool",
-	"duplicate_tool_call_id",
-	"tool_choice_none_violated",
-	"unexpected_tool_calls"
-]);
-/**
-* Local rate-limit codes: the call never reached the provider, so it says
-* nothing about the provider's health, and retrying either just requeues
-* behind the same limit (the two queue codes) or can never succeed at all
-* (`rate_limit_capacity_exceeded`). Shared for the same reason as
-* {@link NON_RETRYABLE_TOOL_CONTRACT_CODES}.
-*/
-const LOCAL_RATE_LIMIT_CODES = new Set([
-	"rate_limit_queue_full",
-	"rate_limit_queue_timeout",
-	"rate_limit_capacity_exceeded"
-]);
-/**
-* Types that are never worth retrying on their own: deterministic
-* caller-input, model-response, or cancellation failures rather than a
-* transient provider fault.
-*/
-const NON_RETRYABLE_TYPES = new Set([
-	"parse",
-	"validation",
-	"invalid_params",
-	"aborted"
-]);
-/**
-* Shared retryability rule behind both `LLMError.retryable` and
-* `LLMErrorSnapshot.retryable`. Pulled out so the two can't drift apart:
-* a snapshot is a point-in-time copy of an error's fields, and this is
-* one of them, so it has to be computed the same way in both places.
-*/
-function computeRetryable(type, code) {
-	if (NON_RETRYABLE_TYPES.has(type)) return false;
-	if (code && NON_RETRYABLE_TOOL_CONTRACT_CODES.has(code)) return false;
-	if (code && LOCAL_RATE_LIMIT_CODES.has(code)) return false;
-	return true;
-}
-/**
-* Returns `issues` unchanged when it can survive `JSON.stringify`.
-* Most `issues` values are VernLLM's own structured shapes (see
-* `LLMErrorIssuesByCode`) and always safe. The one exception is a
-* schema validation failure, where `issues` is a caller supplied
-* `SchemaLike` validator's own `error: unknown`, not controlled by
-* VernLLM and not guaranteed to be circular free. Rather than silently
-* dropping it in that case, this returns a marker string so a reader
-* of serialized output can tell "no issues data" apart from "issues
-* existed but could not be shown".
-*/
-function safeIssues(issues) {
-	if (issues === void 0) return void 0;
-	try {
-		JSON.stringify(issues);
-		return issues;
-	} catch {
-		return "[Unserializable: issues contained a circular reference]";
-	}
-}
-/**
-* 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
-* keeps that path bounded the same way a circular `issues` value is
-* bounded, rather than assuming well formed input.
-*/
-const MAX_ATTEMPTS_DEPTH = 20;
-/**
-* Returns a copy of `attempts` with every nested snapshot's `issues`
-* re-checked through `safeIssues`, recursively through each snapshot's
-* own `attempts`. Needed for two reasons: `safeIssues` returns a safe
-* `issues` value by reference, so a shared object can be mutated into a
-* 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.
-*/
-function safeAttempts(attempts, depth = 0) {
-	if (attempts === void 0) return void 0;
-	if (depth >= MAX_ATTEMPTS_DEPTH) return [];
-	return attempts.map((attempt) => ({
-		...attempt,
-		error: {
-			...attempt.error,
-			issues: safeIssues(attempt.error.issues),
-			attempts: safeAttempts(attempt.error.attempts, depth + 1)
-		}
-	}));
-}
-var LLMError = class extends Error {
-	status;
-	issues;
-	cause;
-	retryAfterMs;
-	/** Stable discriminator within `type`. Absent on errors predating it. */
-	code;
-	/** Every attempt made before this error was thrown, in order. Absent when nothing was retried. */
-	attempts;
-	constructor(message, type, options = {}) {
-		super(message);
-		this.type = type;
-		this.name = "LLMError";
-		this.status = options.status;
-		this.issues = options.issues;
-		this.cause = options.cause;
-		this.retryAfterMs = options.retryAfterMs;
-		this.code = options.code;
-		this.attempts = options.attempts;
-	}
-	/**
-	* Computed purely from `type`/`code`, independent of any specific call's
-	* `nonRetryableStatus` list. False for `parse`/`validation`/
-	* `invalid_params`/`aborted` types (the caller's own input, the model's
-	* own response, or intentional cancellation, none of which are the
-	* provider being unhealthy), the tool contract codes, and the local
-	* rate limit codes. Subclasses (see `FallbackExhaustedError`) may
-	* override this when `type` alone carries no retry signal.
-	*/
-	get retryable() {
-		return computeRetryable(this.type, this.code);
-	}
-	/**
-	* Copies this error's fields into an {@link LLMErrorSnapshot}, for
-	* recording as a `RetryAttempt`/`FallbackAttempt`. `retryable` is
-	* captured here since a snapshot has no getter of its own. `cause` is
-	* not copied, see `LLMErrorSnapshot`'s own doc. `issues` and every
-	* nested `attempts` entry's own `issues` go through `safeAttempts`,
-	* since a schema validation failure's `issues` is a caller supplied
-	* value, not controlled by VernLLM, and `attempts` is itself a public
-	* constructor option a caller can hand build.
-	*/
-	toSnapshot() {
-		return {
-			message: this.message,
-			type: this.type,
-			status: this.status,
-			issues: safeIssues(this.issues),
-			retryAfterMs: this.retryAfterMs,
-			code: this.code,
-			retryable: this.retryable,
-			attempts: safeAttempts(this.attempts)
-		};
-	}
-	/**
-	* Controls what `JSON.stringify(err)` produces. Omits `cause` for the
-	* same reason `toSnapshot()` does: `cause` is `unknown` and never
-	* validated by VernLLM, and some SDK errors carry circular structures
-	* `JSON.stringify` cannot serialize at all. Read `err.cause` directly
-	* instead. `issues`, including every nested `attempts` entry's own
-	* `issues`, goes through `safeAttempts` for the same reason: a schema
-	* validation failure's `issues` is caller supplied and not guaranteed
-	* circular free. Also includes `message` and `retryable`, which a
-	* plain property walk would otherwise miss: `message` is
-	* non-enumerable on `Error`, and `retryable` is a getter, not an own
-	* property.
-	*/
-	toJSON() {
-		return {
-			name: this.name,
-			message: this.message,
-			type: this.type,
-			status: this.status,
-			issues: safeIssues(this.issues),
-			retryAfterMs: this.retryAfterMs,
-			code: this.code,
-			retryable: this.retryable,
-			attempts: safeAttempts(this.attempts)
-		};
-	}
-};
-function isLLMError(err) {
-	return err instanceof LLMError;
-}
-/**
-* Narrows `err.issues` to the exact shape {@link LLMErrorIssuesByCode} maps
-* `code` to, for any code listed there. `code` stays the only discriminator
-* VernLLM uses; this just gives that existing check a typed return instead
-* of requiring a manual cast of `issues`:
-*
-* ```ts
-* if (isLLMError(err) && hasIssues(err, 'duplicate_tool_names')) {
-*   console.log(err.issues.names); // string[], no cast needed
-* }
-* ```
-*/
-function hasIssues(err, code) {
-	return err.code === code && err.issues !== void 0;
-}
+`);for(;i!==-1;){let e=n.slice(0,i);n=n.slice(i+2);let t=G(e);if(t===H)return;t!==U&&(yield t),i=n.indexOf(`
 
-//#endregion
-//#region src/types/cache.ts
-/**
-* Trivial default so the package works out of the box with no external deps
-* Not shared across processes, swap in Redis/Upstash/etc for production
-*/
-var InMemoryCacheAdapter = class {
-	store = new Map();
-	constructor(maxSize = 1e3) {
-		this.maxSize = maxSize;
-	}
-	async get(key) {
-		const entry = this.store.get(key);
-		if (!entry) return {
-			hit: false,
-			value: null
-		};
-		if (Date.now() >= entry.expiresAt) {
-			this.store.delete(key);
-			return {
-				hit: false,
-				value: null
-			};
-		}
-		return {
-			hit: true,
-			value: entry.value
-		};
-	}
-	async set(key, value, ttl) {
-		this.cleanupExpiredEntries();
-		this.store.set(key, {
-			value,
-			expiresAt: Date.now() + ttl * 1e3
-		});
-		this.enforceSizeLimit();
-	}
-	async delete(key) {
-		this.store.delete(key);
-	}
-	cleanupExpiredEntries() {
-		const now = Date.now();
-		for (const [key, entry] of this.store) if (now >= entry.expiresAt) this.store.delete(key);
-	}
-	enforceSizeLimit() {
-		while (this.store.size > this.maxSize) {
-			const oldestKey = this.store.keys().next().value;
-			if (oldestKey === void 0) break;
-			this.store.delete(oldestKey);
-		}
-	}
-};
-/**
-* Normalizes keys before caching to avoid duplicate entries from formatting differences.
-*/
-var NormalizedCacheAdapter = class {
-	constructor(inner = new InMemoryCacheAdapter()) {
-		this.inner = inner;
-	}
-	normalize(key) {
-		return key.toLowerCase().trim().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
-	}
-	async resolveKey(key) {
-		return this.normalize(key);
-	}
-	async get(key) {
-		return this.inner.get(this.normalize(key));
-	}
-	async set(key, value, ttl) {
-		await this.inner.set(this.normalize(key), value, ttl);
-	}
-	async delete(key) {
-		await this.inner.delete?.(this.normalize(key));
-	}
-};
-/**
-* Two-tier cache with fast local L1 and shared L2.
-* L2 hits are promoted back to L1.
-*/
-var TieredCacheAdapter = class {
-	constructor(l1, l2, l1Ttl) {
-		this.l1 = l1;
-		this.l2 = l2;
-		this.l1Ttl = l1Ttl;
-	}
-	/**
-	* Forwards to L1's `resolveKey` if it has one, otherwise L2's. L1 is
-	* preferred since `get()` checks L1 first, so its notion of "the same
-	* key" is the one that determines whether a lookup can skip L2 entirely.
-	*/
-	async resolveKey(key) {
-		if (this.l1.resolveKey) return this.l1.resolveKey(key);
-		if (this.l2.resolveKey) return this.l2.resolveKey(key);
-		return key;
-	}
-	async get(key) {
-		const l1Result = await this.l1.get(key);
-		if (l1Result.hit) return l1Result;
-		const l2Result = await this.l2.get(key);
-		if (l2Result.hit) await this.l1.set(key, l2Result.value, this.l1Ttl ?? 60);
-		return l2Result;
-	}
-	async set(key, value, ttl) {
-		await Promise.all([this.l1.set(key, value, this.l1Ttl ?? ttl), this.l2.set(key, value, ttl)]);
-	}
-	async delete(key) {
-		await Promise.all([this.l1.delete?.(key), this.l2.delete?.(key)]);
-	}
-};
+`)}}try{n+=t.decode()}catch(e){throw new f(`Invalid UTF-8 in SSE stream`,`parse`,{cause:e})}n=n.replace(/\r$/,`
+`);let r=n.indexOf(`
 
-//#endregion
-//#region src/types/tools.ts
-/**
-* Runtime-safe check for whether a `call()` result is a `tool_calls`
-* result. Prefer this over relying on TypeScript's static narrowing
-* whenever `params` passed to `call()` wasn't a literal with `tools`
-* inlined (see the "note on the overload" in `VernLLM.call`'s docs), in
-* that case TS may have typed the result as plain `T` even though it's
-* actually a `CallWithToolsResult<T>` at runtime, and this check works
-* either way.
-*/
-function isToolCallResult(result) {
-	return typeof result === "object" && result !== null && "type" in result && result.type === "tool_calls" && Array.isArray(result.toolCalls);
-}
+`);for(;r!==-1;){let e=n.slice(0,r);n=n.slice(r+2);let t=G(e);if(t===H)return;t!==U&&(yield t),r=n.indexOf(`
 
-//#endregion
-//#region src/types/fallback.ts
-/** Tool contract failures are the model ignoring the request, not a sick provider: repeating it elsewhere can't help. */
-const TOOL_CONTRACT_CODES = new Set([
-	"unknown_tool",
-	"duplicate_tool_call_id",
-	"tool_choice_none_violated",
-	"unexpected_tool_calls"
-]);
-/**
-* The default `fallbackOn` policy. Exported so a caller can wrap rather
-* than replace it, e.g. `fallbackOn: (e, ctx) => myCheck(e) ? 'stop' : defaultFallbackOn(e, ctx)`.
-*/
-const defaultFallbackOn = (error) => {
-	if (error.type === "parse" || error.type === "validation" || error.type === "aborted") return "stop";
-	if (error.type === "quota_exceeded") return "stop";
-	if (error.code && TOOL_CONTRACT_CODES.has(error.code)) return "stop";
-	return "next";
-};
-/**
-* Thrown when the chain gives up, whether because the last target failed
-* or `fallbackOn` chose to stop early. Carries each attempt in order so
-* an outage across providers stays debuggable without reproducing it.
-* Extends `LLMError` so `isLLMError` and any `instanceof LLMError` check
-* still passes, inheriting the last failure's `type`/`status`/`retryAfterMs`
-* so existing type-based handling, including reading `retryAfterMs` on an
-* `'api'`-typed error, keeps working on a fallback-exhausted error too.
-*/
-var FallbackExhaustedError = class extends LLMError {
-	constructor(attempts) {
-		const last = attempts[attempts.length - 1]?.error;
-		super(`${attempts.length} provider${attempts.length === 1 ? "" : "s"} attempted and failed: ${attempts.map((a) => `${a.provider}(${a.error.type})`).join(" then ")}`, "fallback_exhausted", {
-			status: last?.status,
-			cause: last,
-			retryAfterMs: last?.retryAfterMs,
-			code: "fallback_exhausted",
-			attempts
-		});
-		this.attempts = attempts;
-	}
-	/**
-	* `type: 'fallback_exhausted'` by itself says nothing about whether
-	* retrying could help; the reason the last target failed does. Defers to
-	* that attempt's own `retryable` instead of anything about this class's
-	* own type.
-	*/
-	get retryable() {
-		const last = this.attempts[this.attempts.length - 1]?.error;
-		return last ? last.retryable : super.retryable;
-	}
-};
-/** Narrows `err` to {@link FallbackExhaustedError}, for direct access to its `attempts` (`provider`/`model` per failed target) without a manual `instanceof` check. */
-function isFallbackExhaustedError(err) {
-	return err instanceof FallbackExhaustedError;
-}
-
-//#endregion
-//#region src/internal/execution/usage.utils.ts
-/**
-* Calls `params.reserveUsage`, if present, mapping any failure to a
-* `quota_exceeded` LLMError (or an aborted error, if the signal fired
-* during reservation). Returns whether a reservation was actually made,
-* so callers know whether a later refund is needed. Shared by
-* `withReservedUsage` and `withReservedUsageForStream`, which differ only
-* in whether `coalesced` is caller-supplied or always `false`.
-*/
-async function reserve(params, coalesced, signal) {
-	if (!params.reserveUsage) return false;
-	try {
-		await params.reserveUsage({
-			coalesced,
-			signal
-		});
-		return true;
-	} catch (error) {
-		if (signal?.aborted) throw new LLMError("LLM request aborted", "aborted");
-		throw new LLMError(error instanceof Error ? error.message : "Usage reservation failed", "quota_exceeded", { cause: error });
-	}
-}
-/**
-* Builds a `(logMessage) => Promise<void>` refund function bound to the
-* given hooks/coalesced/signal, reporting (instead of throwing) any error
-* the refund hook itself raises, so a broken refund hook never masks the
-* original error it was called to clean up after.
-*/
-function makeRefund(params, coalesced, signal, onRefundError) {
-	return async (logMessage) => {
-		try {
-			await params.refundUsage?.({
-				coalesced,
-				signal
-			});
-		} catch (refundError) {
-			onRefundError(logMessage, refundError);
-		}
-	};
-}
-/**
-* Runs `getResult` after reserving usage, if a `reserveUsage` hook was
-* provided. `refundUsage` fires only if a reservation was actually made.
-* `onRefundError` is called (instead of throwing) whenever a refund attempt
-* itself fails, so a broken refund hook never masks the original error.
-*/
-async function withReservedUsage(params, coalesced, getResult, signal, onRefundError) {
-	if (signal?.aborted) throw new LLMError("LLM request aborted", "aborted");
-	const reserved = await reserve(params, coalesced, signal);
-	const refund = makeRefund(params, coalesced, signal, onRefundError);
-	if (signal?.aborted) {
-		if (reserved) await refund("[VernLLM] refundUsage failed after abort");
-		throw new LLMError("LLM request aborted", "aborted");
-	}
-	let result;
-	try {
-		result = await getResult();
-	} catch (error) {
-		if (reserved) await refund("[VernLLM] refundUsage failed");
-		throw error;
-	}
-	if (signal?.aborted) {
-		if (reserved) await refund("[VernLLM] refundUsage failed after abort");
-		throw new LLMError("LLM request aborted", "aborted");
-	}
-	return result;
-}
-/**
-* Streaming counterpart to `withReservedUsage`. `withReservedUsage` assumes
-* `getResult()` settling *is* the operation's final outcome, awaiting it
-* synchronously before reserve/refund resolve. Streaming can't satisfy that:
-* `call()` must return `{ chunks, finalResult }` as soon as the stream
-* opens, well before the real outcome (validation, schema/tool-call checks)
-* is known.
-*
-* Reserves usage before `openStream` runs, same failure mode as the
-* non-streaming path if `reserveUsage` itself throws (mapped to
-* `quota_exceeded`, nothing opened). If `openStream` itself throws (stream
-* never opened), refunds synchronously and rethrows, exactly like
-* `withReservedUsage` does today. If it succeeds, returns `{ chunks,
-* finalResult }` immediately, refund/report is deferred onto
-* `finalResult`'s continuation, since that's the only point the real
-* outcome is known. This means `onUsageFailure` (and any refund) can fire
-* well after this function itself has returned.
-*/
-async function withReservedUsageForStream(params, openStream, signal, onRefundError) {
-	if (signal?.aborted) throw new LLMError("LLM request aborted", "aborted");
-	const reserved = await reserve(params, false, signal);
-	const refund = makeRefund(params, false, signal, onRefundError);
-	if (signal?.aborted) {
-		if (reserved) await refund("[VernLLM] refundUsage failed after abort");
-		throw new LLMError("LLM request aborted", "aborted");
-	}
-	let opened;
-	try {
-		opened = await openStream();
-	} catch (error) {
-		if (reserved) await refund("[VernLLM] refundUsage failed after stream-open failure");
-		throw error;
-	}
-	const finalResult = opened.finalResult.then((value) => value, async (error) => {
-		if (reserved) await refund("[VernLLM] refundUsage failed after stream error");
-		throw error;
-	});
-	finalResult.catch(() => {});
-	return {
-		chunks: opened.chunks,
-		finalResult
-	};
-}
-
-//#endregion
-//#region src/internal/cache/replay.utils.ts
-/**
-* Converts an already-known cache value back into a plausible "text" form
-* for a one-shot replay chunk: passed through unchanged if it's already a
-* string (the `jsonMode: false` case), otherwise `JSON.stringify`'d (the
-* `jsonMode: true` case, where the cached value is the *parsed* result, not
-* the original raw text). This is a reasonable reconstruction, not a
-* byte-identical replay of whatever text the model originally streamed,
-* good enough for `for await (const c of chunks)` call sites that don't
-* branch on hit vs. miss, which is the only thing a cache-hit replay needs
-* to support.
-*/
-function toReplayText(value) {
-	return typeof value === "string" ? value : JSON.stringify(value) ?? "";
-}
-/**
-* Builds a trivially-exhausted one-shot `chunks` iterable from an
-* already-known value, used for a `cachedCall` cache hit, where there's no
-* live generation to relay (see `VernLLM.cachedCall`'s docs). No `usage`
-* chunk is emitted: a cache hit spent no real tokens, so there's nothing to
-* report, matching how non-streaming `cachedCall` never calls `onUsage` on
-* a hit either.
-*
-* `hasTools` must reflect whether the *original* call that produced this
-* cached value had `tools` set, that's what determines whether `value` is
-* `T` directly or a `CallWithToolsResult<T>` wrapper, and it isn't
-* something that can be reliably guessed from the value's shape alone
-* (a `schema`-validated `T` could coincidentally look like a
-* `CallWithToolsResult`).
-*/
-function buildReplayChunks(value, hasTools) {
-	const items = [];
-	if (hasTools) {
-		const result = value;
-		if (result.type === "tool_calls") {
-			result.toolCalls.forEach((toolCall, index) => {
-				items.push({
-					type: "tool_call_delta",
-					index,
-					id: toolCall.id,
-					name: toolCall.name,
-					argsDelta: JSON.stringify(toolCall.arguments ?? {}),
-					complete: true
-				});
-			});
-			if (result.content) items.push({
-				type: "text-delta",
-				delta: result.content
-			});
-		} else items.push({
-			type: "text-delta",
-			delta: toReplayText(result.content)
-		});
-	} else items.push({
-		type: "text-delta",
-		delta: toReplayText(value)
-	});
-	return { async *[Symbol.asyncIterator]() {
-		for (const item of items) yield item;
-	} };
-}
-/**
-* Streaming counterpart to `buildReplayChunks` for a `cachedCall` that
-* *joined* an already-in-flight call for the same key rather than
-* triggering one itself (see `runCachedStream`'s in-flight-coalescing
-* path): there's no live stream to relay (it isn't this call's stream to
-* relay, see the joiner-path comment in `runCachedStream`), but there's
-* also no value yet, only a pending promise for one. Waits for `promise`,
-* then delegates to `buildReplayChunks`. If `promise` rejects, iterating
-* `chunks` throws that same error, consistent with how a live stream's
-* `chunks` throws on a mid-stream failure.
-*/
-function buildReplayChunksFromPromise(promise, hasTools) {
-	return { async *[Symbol.asyncIterator]() {
-		const value = await promise;
-		yield* buildReplayChunks(value, hasTools);
-	} };
-}
-
-//#endregion
-//#region src/internal/cache/cacheOrchestrator.ts
-/**
-* Owns cache key resolution, cache reads/writes, and in-flight coalescing
-* for concurrent misses on the same key. Doesn't know about `CallExecutor`,
-* retries, or providers at all: `fn`/`openStream` are opaque callbacks
-* (`VernLLM.cachedCall` passes `() => this.call(...)`), so this class only
-* needs the cache adapter and a logger. Extracted from `VernLLM` since
-* caching and per-target call mechanics are independent concerns that
-* happened to live on the same class.
-*/
-var CacheOrchestrator = class {
-	inFlight = new Map();
-	constructor(cache, logger) {
-		this.cache = cache;
-		this.logger = logger;
-	}
-	/** Resolves a cache key through the adapter when it supports normalization. */
-	async resolveCacheKey(key) {
-		return this.cache.resolveKey ? await this.cache.resolveKey(key) : key;
-	}
-	/**
-	* Removes a cached response by key when the configured cache adapter
-	* supports deletion. Cache invalidation is the caller's responsibility;
-	* only the application knows when cached data is stale.
-	*/
-	async deleteCache(key) {
-		if (!this.cache.delete) return;
-		try {
-			await this.cache.delete(await this.resolveCacheKey(key));
-		} catch (error) {
-			this.logger.warn(`[VernLLM] cache delete failed: ${error instanceof Error ? error.message : "unknown"}`);
-		}
-	}
-	/** Logs a failed refundUsage attempt via the configured logger. */
-	logRefundError(logMessage, error) {
-		this.logger.error(logMessage, { message: error instanceof Error ? error.message : "unknown" });
-	}
-	/**
-	* Reads from the cache, treating a failed adapter read as a miss rather
-	* than letting it fail the call. The request still falls through to a
-	* real provider call, but that fallback is now logged instead of silent.
-	*/
-	async getCached(key) {
-		try {
-			return await this.cache.get(key);
-		} catch (error) {
-			this.logger.warn(`[VernLLM] cache read failed: ${error instanceof Error ? error.message : "unknown"}`);
-			return { hit: false };
-		}
-	}
-	/**
-	* Internal cache primitive around caller-supplied logic. Concurrent misses
-	* for the same `cacheKey` share a single in-flight call, avoiding cache
-	* stampedes.
-	*
-	* Backs the public `VernLLM.cachedCall()`, which always composes this
-	* with `call()` so cached results get the same retry/timeout/
-	* circuit-breaker guarantees as any other LLM call.
-	*
-	* @param params `cacheKey`, `ttl`, `fn` (the work to run on a cache
-	* miss, typically `() => this.call(...)`), and optional
-	* `reserveUsage`/`refundUsage`/`signal`. See `InternalCacheParams`.
-	* @returns The cached value on a hit, or the result of `fn()` on a miss.
-	*/
-	async runCached(params) {
-		const resolvedKey = await this.resolveCacheKey(params.cacheKey);
-		const resolvedParams = resolvedKey === params.cacheKey ? params : {
-			...params,
-			cacheKey: resolvedKey
-		};
-		const cached = await this.getCached(resolvedKey);
-		if (cached.hit) return cached.value;
-		const existing = this.inFlight.get(resolvedKey);
-		if (existing) return withReservedUsage(resolvedParams, true, () => existing, params.signal, (logMessage, error) => this.logRefundError(logMessage, error));
-		return this.registerTrigger(resolvedParams);
-	}
-	/** Starts the shared fn() call for a cache miss and tracks it in the in-flight map until it settles. */
-	registerTrigger(params) {
-		const resultPromise = withReservedUsage(params, false, () => this.runAndCache(params), params.signal, (logMessage, error) => this.logRefundError(logMessage, error));
-		this.inFlight.set(params.cacheKey, resultPromise);
-		resultPromise.catch(() => {}).finally(() => {
-			this.inFlight.delete(params.cacheKey);
-		});
-		return resultPromise;
-	}
-	/** Runs `fn` and writes its result to the cache. */
-	async runAndCache(params) {
-		const result = await params.fn();
-		try {
-			await this.cache.set(params.cacheKey, result, params.ttl);
-		} catch (error) {
-			this.logger.warn(`[VernLLM] cache write failed: ${error instanceof Error ? error.message : "unknown"}`);
-		}
-		return result;
-	}
-	/**
-	* Streaming counterpart to `runCached`. Three cases:
-	*
-	* - Hit: no live generation to relay. Returns immediately with
-	*   `finalResult` resolved to the cached value and a one-shot `chunks`
-	*   replay built from it, so `for await (const c of chunks)` call sites
-	*   work identically on a hit or a miss. No usage hooks fire, since
-	*   nothing was actually spent.
-	* - Miss, nothing else in flight for this key: delegates to
-	*   `registerStreamTrigger`, which opens the stream and relays its
-	*   `chunks` live.
-	* - Miss, but another call for the same key is already in flight: this
-	*   call has no live chunks of its own to relay, so it's treated like a
-	*   delayed hit. `finalResult` shares the trigger's in-flight promise
-	*   (the same in-flight map non-streaming `runCached` uses, so
-	*   streaming and non-streaming calls for the same key coalesce
-	*   against each other too), and `chunks` is a one-shot replay built
-	*   once that promise resolves.
-	*/
-	async runCachedStream(params, hasTools) {
-		const resolvedKey = await this.resolveCacheKey(params.cacheKey);
-		const resolvedParams = resolvedKey === params.cacheKey ? params : {
-			...params,
-			cacheKey: resolvedKey
-		};
-		const cached = await this.getCached(resolvedKey);
-		if (cached.hit) {
-			const value = cached.value;
-			return {
-				chunks: buildReplayChunks(value, hasTools),
-				finalResult: Promise.resolve(value)
-			};
-		}
-		const existing = this.inFlight.get(resolvedKey);
-		if (existing) {
-			const finalResult = withReservedUsage(resolvedParams, true, () => existing, params.signal, (logMessage, error) => this.logRefundError(logMessage, error));
-			finalResult.catch(() => {});
-			return {
-				chunks: buildReplayChunksFromPromise(finalResult, hasTools),
-				finalResult
-			};
-		}
-		return this.registerStreamTrigger(resolvedParams);
-	}
-	/**
-	* Opens the shared stream for a cache miss and tracks its settled value
-	* in the in-flight map until it resolves or rejects. Writes to the cache
-	* on success only, matching `runAndCache`.
-	*
-	* Registers the in-flight promise synchronously, before anything async
-	* runs, so a concurrent `cachedCall` for the same key always sees it in
-	* time to join instead of triggering its own stream. Settlement is
-	* wired onto the whole `withReservedUsageForStream` call rather than a
-	* line inside its callback, so any failure point (reserving usage,
-	* opening the stream, or the stream itself) reliably settles the
-	* in-flight entry instead of leaving it stuck.
-	*/
-	registerStreamTrigger(params) {
-		let resolveInFlight;
-		let rejectInFlight;
-		const inFlightResult = new Promise((resolve, reject) => {
-			resolveInFlight = resolve;
-			rejectInFlight = reject;
-		});
-		this.inFlight.set(params.cacheKey, inFlightResult);
-		inFlightResult.catch(() => {}).finally(() => {
-			this.inFlight.delete(params.cacheKey);
-		});
-		const streamPromise = withReservedUsageForStream(params, async () => {
-			const opened = await params.openStream();
-			const trackedResult = opened.finalResult.then(async (value) => {
-				try {
-					await this.cache.set(params.cacheKey, value, params.ttl);
-				} catch (error) {
-					this.logger.warn(`[VernLLM] cache write failed: ${error instanceof Error ? error.message : "unknown"}`);
-				}
-				return value;
-			}, (error) => {
-				throw error;
-			});
-			return {
-				chunks: opened.chunks,
-				finalResult: trackedResult
-			};
-		}, params.signal, (logMessage, error) => this.logRefundError(logMessage, error));
-		streamPromise.then((opened) => {
-			opened.finalResult.then(resolveInFlight, rejectInFlight);
-		}, (error) => {
-			rejectInFlight(error);
-		});
-		return streamPromise;
-	}
-};
-
-//#endregion
-//#region src/circuitBreaker.ts
-function newBucket() {
-	return {
-		state: "closed",
-		consecutiveFailures: 0,
-		openedAt: 0,
-		trialInFlight: false
-	};
-}
-/** Key a bucket lookup falls into when the call omitted `model` under `isolateByModel`. */
-const UNLABELED_MODEL = "";
-/**
-* Per retry VernLLM-instance circuit breaker. Tracks consecutive failures across
-* calls. Once the threshold is hit, short-circuits new calls with an
-* LLMError('circuit_open') instead of hitting the provider, until the
-* cooldown elapses and a single trial call is allowed through
-*/
-var CircuitBreaker = class {
-	threshold;
-	cooldownMs;
-	onStateChange;
-	/** Whether this breaker tracks failures per model instead of one shared circuit. Read by `CallExecutor`/`VernLLM` to report per-target in `getCircuitStates`. */
-	isolateByModel;
-	sharedBucket = newBucket();
-	bucketsByModel = new Map();
-	constructor(options = {}) {
-		this.threshold = options.threshold ?? 5;
-		this.cooldownMs = options.cooldownMs ?? 3e4;
-		this.onStateChange = options.onStateChange;
-		this.isolateByModel = options.isolateByModel ?? false;
-	}
-	/** Returns the bucket for a model if one already exists, without allocating. */
-	lookupBucket(model) {
-		if (!this.isolateByModel) return this.sharedBucket;
-		const key = model ?? UNLABELED_MODEL;
-		return this.bucketsByModel.get(key);
-	}
-	/** Creates and stores a bucket for a model when the first mutation needs one. */
-	ensureBucketFor(model) {
-		if (!this.isolateByModel) return this.sharedBucket;
-		const key = model ?? UNLABELED_MODEL;
-		let bucket = this.bucketsByModel.get(key);
-		if (!bucket) {
-			bucket = newBucket();
-			this.bucketsByModel.set(key, bucket);
-		}
-		return bucket;
-	}
-	/** Every state mutation routes through here, so `onStateChange` fires exactly once per real change. */
-	transition(bucket, to, model) {
-		if (to === bucket.state) return;
-		const from = bucket.state;
-		bucket.state = to;
-		this.onStateChange?.(from, to, bucket.consecutiveFailures, model);
-	}
-	/**
-	* Throws if the circuit is open and the cooldown hasn't elapsed, or if
-	* the circuit is half-open and a trial call is already in flight.
-	* Otherwise, if the circuit just became eligible for a trial (cooldown
-	* elapsed, or half-open with no trial currently running), this call
-	* becomes that trial
-	*/
-	assertClosed(model) {
-		const bucket = this.ensureBucketFor(model);
-		if (bucket.state === "closed") return;
-		if (bucket.state === "open") {
-			const elapsed = Date.now() - bucket.openedAt;
-			if (elapsed < this.cooldownMs) throw new LLMError(`Circuit open, provider has failed ${bucket.consecutiveFailures} times in a row. Retry in ${Math.ceil((this.cooldownMs - elapsed) / 1e3)}s.`, "circuit_open", { code: "circuit_cooling_down" });
-			bucket.trialInFlight = true;
-			this.transition(bucket, "half-open", model);
-			return;
-		}
-		if (bucket.trialInFlight) throw new LLMError("Circuit half-open. A trial request is already in flight. Try again shortly.", "circuit_open", { code: "circuit_trial_in_flight" });
-		bucket.trialInFlight = true;
-	}
-	recordSuccess(model) {
-		const bucket = this.lookupBucket(model);
-		if (!bucket) return;
-		bucket.consecutiveFailures = 0;
-		bucket.trialInFlight = false;
-		this.transition(bucket, "closed", model);
-		if (this.isolateByModel && bucket.state === "closed" && bucket.consecutiveFailures === 0) this.bucketsByModel.delete(model ?? UNLABELED_MODEL);
-	}
-	recordFailure(model) {
-		const bucket = this.ensureBucketFor(model);
-		bucket.consecutiveFailures += 1;
-		bucket.trialInFlight = false;
-		if (bucket.state === "half-open") {
-			bucket.openedAt = Date.now();
-			this.transition(bucket, "open", model);
-			return;
-		}
-		if (bucket.consecutiveFailures >= this.threshold) {
-			bucket.openedAt = Date.now();
-			this.transition(bucket, "open", model);
-		}
-	}
-	/**
-	* With `isolateByModel` off (the default), `model` is ignored and the
-	* one shared circuit's state is returned, unchanged from every version
-	* before this option existed. With `isolateByModel` on, returns that
-	* model's own state, `'closed'` for a model never seen yet, same as a
-	* fresh breaker.
-	*/
-	getState(model) {
-		return this.lookupBucket(model)?.state ?? "closed";
-	}
-	/**
-	* Manually opens the circuit, as if `threshold` consecutive failures had
-	* just happened, e.g. to pull a provider out of rotation ahead of known
-	* maintenance. Resets the cooldown window from now, same as a real
-	* threshold-crossing failure would, and clears any in-flight half-open
-	* trial since it no longer applies once the circuit is (re)opened.
-	*/
-	open(model) {
-		const bucket = this.ensureBucketFor(model);
-		bucket.openedAt = Date.now();
-		bucket.trialInFlight = false;
-		this.transition(bucket, "open", model);
-	}
-	/**
-	* Manually closes the circuit and resets its failure count, e.g. once a
-	* provider is confirmed healthy again without waiting out the cooldown.
-	* Mirrors `recordSuccess`'s bookkeeping (including dropping the
-	* per-model bucket under `isolateByModel`, once idle) but without
-	* requiring an actual successful call first.
-	*/
-	close(model) {
-		const bucket = this.ensureBucketFor(model);
-		bucket.consecutiveFailures = 0;
-		bucket.trialInFlight = false;
-		this.transition(bucket, "closed", model);
-		if (this.isolateByModel && bucket.state === "closed" && bucket.consecutiveFailures === 0) this.bucketsByModel.delete(model ?? UNLABELED_MODEL);
-	}
-};
-
-//#endregion
-//#region src/internal/circuitBreaker.utils.ts
-/**
-* Builds a `(event) => void` reporter that no-ops when `onEvent` is unset,
-* and otherwise calls it, swallowing and logging any error the handler
-* throws so a broken `onEvent` can't break the call that triggered it.
-* Shared by `buildCircuitBreaker` (which needs to report before any
-* executor exists) and `CallExecutor.reportEvent`, kept independent of the
-* executor for that reason.
-*/
-function makeEventReporter(onEvent, logger) {
-	return (event) => {
-		if (!onEvent) return;
-		try {
-			onEvent(event);
-		} catch (error) {
-			logger.error("[VernLLM] onEvent failed", { message: error instanceof Error ? error.message : "unknown" });
-		}
-	};
-}
-/**
-* Builds the optional circuit breaker for one provider target, wiring its
-* `onStateChange` to emit a `circuit_state` event and chain any
-* caller-supplied `onStateChange`. Returns `undefined` when
-* `circuitBreakerOption` is falsy, matching the option's own semantics.
-*
-* Lives outside `CallExecutor` (and outside `VernLLM`, once this were
-* inlined) because the breaker has to exist *before* the executor it's
-* passed into, so its construction can't be an executor concern.
-* `onEvent` is called directly rather than through the executor for the
-* same reason: nothing executor-shaped exists yet at this point.
-*
-* Takes the specific fields it needs (rather than a full `VernLLMOptions`)
-* so it works identically for the primary target and for each fallback
-* target, which carry their own `circuitBreaker` override alongside the
-* shared `onEvent`.
-*/
-function buildCircuitBreaker(circuitBreakerOption, providerName, defaultModel, onEvent, logger) {
-	if (!circuitBreakerOption) return void 0;
-	const breakerOptions = typeof circuitBreakerOption === "object" ? circuitBreakerOption : void 0;
-	const userOnStateChange = breakerOptions?.onStateChange;
-	const reportEvent = makeEventReporter(onEvent, logger);
-	return new CircuitBreaker({
-		...breakerOptions,
-		onStateChange: (from, to, consecutiveFailures, model) => {
-			reportEvent({
-				kind: "circuit_state",
-				provider: providerName,
-				model: model ?? defaultModel,
-				from,
-				to,
-				consecutiveFailures
-			});
-			if (!userOnStateChange) return;
-			try {
-				userOnStateChange(from, to, consecutiveFailures, model);
-			} catch (error) {
-				logger.error("[VernLLM] circuitBreaker.onStateChange failed", { message: error instanceof Error ? error.message : "unknown" });
-			}
-		}
-	});
-}
-
-//#endregion
-//#region src/internal/execution/retry.utils.ts
-/**
-* Default cap (ms) for both exponential backoff and honored Retry-After
-* values, so a misbehaving/adversarial Retry-After can't stall a caller
-* indefinitely
-*/
-const DEFAULT_MAX_DELAY_MS = 1e4;
-/**
-* `setTimeout` silently clamps any delay above this (~24.8 days) or
-* `Infinity` down to ~1ms instead of erroring, so a caller passing
-* `Infinity` as "no timeout" gets the opposite of what they asked for.
-* Both timeout helpers below guard against this explicitly.
-*/
-const MAX_SETTIMEOUT_MS = 2147483647;
-/**
-* Resolves a timeout value to the number `setTimeout` should actually use,
-* or `undefined` when the timeout should be treated as disabled (0,
-* negative, or `Infinity`). Returning the resolved value directly, rather
-* than a boolean, lets callers narrow `number | undefined` to `number`
-* without an `as number` cast.
-*/
-function resolveActiveTimeoutMs(ms) {
-	return !ms || ms <= 0 || ms === Infinity ? void 0 : ms;
-}
-/** Caps a timeout at the largest delay `setTimeout` actually honors. */
-function clampTimeoutMs(ms) {
-	return Math.min(ms, MAX_SETTIMEOUT_MS);
-}
-/**
-* Runs an async function and cancels it if it takes longer than the given
-* timeout. Creates an internal abort controller that fires after the
-* timeout elapses, and combines it with any external signal the caller
-* passed in so either one can cancel the underlying call. If the internal
-* timeout triggers and the underlying operation aborts, the error is
-* converted into an LLMError with type "timeout". External cancellations
-* continue to propagate as aborted errors. The internal timer is always
-* cleared afterward, whether the function succeeds, fails, or is aborted,
-* so nothing is left running in the background.
-*
-* `timeoutMs` of `Infinity` (or any value beyond what `setTimeout` can
-* represent) disables the timeout rather than firing almost immediately.
-*/
-async function withTimeout(fn, timeoutMs, externalSignal) {
-	const controller = new AbortController();
-	const activeTimeoutMs = resolveActiveTimeoutMs(timeoutMs);
-	const timer = activeTimeoutMs === void 0 ? void 0 : setTimeout(() => {
-		controller.abort();
-	}, clampTimeoutMs(activeTimeoutMs));
-	const signal = externalSignal ? AbortSignal.any([externalSignal, controller.signal]) : controller.signal;
-	try {
-		return await fn(signal);
-	} catch (err) {
-		if (controller.signal.aborted && !externalSignal?.aborted && err instanceof DOMException && err.name === "AbortError") throw new LLMError("Request timed out", "timeout", { code: "request_timeout" });
-		throw err;
-	} finally {
-		clearTimeout(timer);
-	}
-}
-/**
-* Races one `iterator.next()` call against a per-call idle timer, to
-* bound the gap *between* chunks (unlike `withTimeout`, which only bounds
-* opening the stream and its first chunk). Without this, a connection
-* that streams one chunk then hangs would never fail.
-*
-* `timeoutMs` of 0/undefined/`Infinity` disables the check. Otherwise
-* rejects with `LLMError('timeout')` if `next()` doesn't settle in time.
-* The clock resets on every call, so the window is measured from the most
-* recent chunk, not from stream start.
-*
-* `onIdle`, if given, is called the moment the timer fires (before the
-* rejection), so callers can abort the underlying transport instead of
-* just walking away from an unread promise. `logger`, if given, records a
-* debug line if `next()` still settles *after* the idle timeout already
-* rejected. `resolve`/`reject` on an already-settled promise is otherwise
-* a silent no-op, so without this the late chunk (possibly the final
-* usage chunk) would vanish with no trace.
-*/
-function withChunkIdleTimeout(next, timeoutMs, onIdle, logger) {
-	const activeTimeoutMs = resolveActiveTimeoutMs(timeoutMs);
-	if (activeTimeoutMs === void 0) return next();
-	let settled = false;
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			settled = true;
-			onIdle?.();
-			reject(new LLMError(`No stream chunk received for ${activeTimeoutMs}ms (idle timeout)`, "timeout", { code: "idle_timeout" }));
-		}, clampTimeoutMs(activeTimeoutMs));
-		next().then((result) => {
-			clearTimeout(timer);
-			if (settled) {
-				logger?.debug("[VernLLM] chunk resolved after idle timeout already fired; discarding");
-				return;
-			}
-			settled = true;
-			resolve(result);
-		}, (error) => {
-			clearTimeout(timer);
-			if (settled) {
-				logger?.debug("[VernLLM] chunk rejection arrived after idle timeout already fired; discarding");
-				return;
-			}
-			settled = true;
-			reject(error);
-		});
-	});
-}
-/**
-* Looks inside an unknown error value for a Retry-After header and
-* converts it to milliseconds. Checks `.headers` first (fetch-style,
-* Headers-like with `.get()`), then `.response.headers` (axios-style,
-* plain object) since different client libraries surface headers
-* differently. Supports both the delta-seconds form ("30") and the
-* HTTP-date form ("Wed, 21 Oct 2015 07:28:00 GMT"). The result is capped
-* at maxDelayMs. Returns undefined when no usable Retry-After is present
-*/
-function extractRetryAfterMs(err, maxDelayMs = DEFAULT_MAX_DELAY_MS) {
-	if (!err || typeof err !== "object") return void 0;
-	const error = err;
-	const headers = error.headers ?? error.response?.headers;
-	if (!headers || typeof headers !== "object") return void 0;
-	const getter = headers;
-	const raw = typeof getter.get === "function" ? getter.get("Retry-After") : Object.entries(headers).find(([name]) => name.toLowerCase() === "retry-after")?.at(1);
-	if (typeof raw !== "string" || raw.trim() === "") return void 0;
-	const trimmed = raw.trim();
-	if (/^\d+$/.test(trimmed)) return Math.max(0, Math.min(Number(trimmed) * 1e3, maxDelayMs));
-	const dateMs = Date.parse(trimmed);
-	if (!Number.isNaN(dateMs)) return Math.max(0, Math.min(dateMs - Date.now(), maxDelayMs));
-	return void 0;
-}
-/**
-* Exponential backoff with jitter, capped at maxDelayMs.
-* Jitter avoids thundering-herd retries when many callers back off in lockstep,
-* the cap prevents unbounded delays when maxRetries is high
-*/
-function getBackoffDelay(baseDelayMs, attempt, maxDelayMs = DEFAULT_MAX_DELAY_MS) {
-	const exp = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
-	return exp / 2 + Math.random() * (exp / 2);
-}
-/**
-* Pauses execution for the given delay before a retry attempt. If an
-* abort signal is provided and it fires while waiting, the pending
-* timer is cancelled immediately and the wait rejects right away with
-* an aborted error instead of continuing to sit idle until the delay
-* would have finished on its own
-*/
-async function waitForRetry(delay, signal) {
-	if (signal?.aborted) throw new LLMError("Operation aborted", "aborted");
-	await new Promise((resolve, reject) => {
-		const onAbort = () => {
-			clearTimeout(timer);
-			reject(new LLMError("Operation aborted", "aborted"));
-		};
-		const timer = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, delay);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-
-//#endregion
-//#region src/internal/execution/errors.utils.ts
-/**
-* Looks inside an unknown error value and pulls out an http status code
-* if one is present. Checks the status field first then the status code
-* field since different client libraries use different names for this,
-* falling back to AWS SDK v3's `$metadata.httpStatusCode` (e.g. Bedrock's
-* `ThrottlingException`), which doesn't set either of the other two.
-* Returns undefined when the error is not an object or carries no status
-*/
-function extractStatus(err) {
-	if (!err || typeof err !== "object") return void 0;
-	const error = err;
-	if (typeof error.status === "number") return error.status;
-	if (typeof error.statusCode === "number") return error.statusCode;
-	if (typeof error.$metadata?.httpStatusCode === "number") return error.$metadata.httpStatusCode;
-	return void 0;
-}
-/**
-* POSIX/libuv error codes libuv (and so Node's `fetch`/undici) attaches to
-* genuine transport-level failures: connection refused, DNS lookup
-* failure, connection reset mid-request, a connect that never completed,
-* DNS server unreachable, broken pipe, or host/network unreachable.
-* Deliberately narrow: only codes that can only mean "the connection
-* itself failed," not anything that could also indicate an application
-* error.
-*/
-const NETWORK_ERROR_CODES = new Set([
-	"ECONNREFUSED",
-	"ENOTFOUND",
-	"ECONNRESET",
-	"ETIMEDOUT",
-	"EAI_AGAIN",
-	"EPIPE",
-	"ECONNABORTED",
-	"EHOSTUNREACH",
-	"ENETUNREACH"
-]);
-/** `fetch`'s own wording for a transport-level failure, across runtimes/browsers. */
-const NETWORK_ERROR_MESSAGES = new Set([
-	"fetch failed",
-	"failed to fetch",
-	"load failed",
-	"networkerror when attempting to fetch resource."
-]);
-/**
-* Whether `error` is, with reasonable confidence, a transport-level
-* failure (never reached the provider, as opposed to the provider itself
-* responding with an error) rather than some other unexpected exception.
-* Checked via explicit, well-known signals only, so a genuinely unknown
-* error never gets misclassified as a connection failure just because it
-* also lacked an HTTP status.
-*/
-function isNetworkError(error) {
-	if (!error || typeof error !== "object") return false;
-	const err = error;
-	if (typeof err.code === "string" && NETWORK_ERROR_CODES.has(err.code)) return true;
-	if (typeof err.message === "string" && NETWORK_ERROR_MESSAGES.has(err.message.toLowerCase())) return true;
-	if (err.cause && typeof err.cause === "object") {
-		const cause = err.cause;
-		if (typeof cause.code === "string" && NETWORK_ERROR_CODES.has(cause.code)) return true;
-	}
-	return false;
-}
-function formatSafely(value) {
-	try {
-		return JSON.stringify(value, null, 2) ?? String(value);
-	} catch {
-		try {
-			return String(value);
-		} catch {
-			return "[unprintable error]";
-		}
-	}
-}
-/**
-* Looks inside an unknown thrown value and pulls out a human-readable
-* description of it. Checks the `error` field first (the provider's raw
-* rejection body, JSON-stringified if possible) then falls back to the
-* message` field. Always returns a safe string, even when the thrown value
-* has hostile properties or cannot be serialized normally.
-*/
-function describeError(err) {
-	if (err && typeof err === "object") try {
-		const error = err;
-		if (error.error !== void 0) return formatSafely(error.error);
-		if (typeof error.message === "string") return error.message;
-	} catch {}
-	return formatSafely(err);
-}
-/**
-* Maps an HTTP status to its corresponding `LLMErrorCode`, derived purely
-* from the status itself so it applies the same way regardless of which
-* adapter or client raised the error. Used both when building a fresh
-* `LLMError` and when filling in a `code` on an already-normalized one
-* that doesn't have one yet, so the two paths can't drift apart.
-*/
-function codeForStatus(status) {
-	switch (status) {
-		case 429: return "provider_rate_limited";
-		case 401: return "authentication";
-		case 403: return "authorization";
-		case 404: return "not_found";
-		case 413: return "payload_too_large";
-		default: return status >= 500 ? "server_error" : void 0;
-	}
-}
-/**
-* 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
-* rather than assigned onto the error afterward, so `attempts` is always
-* settled once, through the constructor, like every other field on
-* `LLMError`.
-*/
-function normalizeError(error, signal, attempts) {
-	if (signal?.aborted) return new LLMError("LLM request aborted", "aborted", { attempts });
-	if (error instanceof LLMError) {
-		if (error.code === void 0 && error.status !== void 0) error.code = codeForStatus(error.status);
-		if (error.attempts === void 0 && attempts !== void 0) error.attempts = attempts;
-		return error;
-	}
-	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 (isNetworkError(error)) return new LLMError("LLM request failed", "network", {
-		cause: error,
-		retryAfterMs,
-		code: "connection_failed",
-		attempts
-	});
-	return new LLMError("LLM request failed", "unknown", {
-		cause: error,
-		retryAfterMs,
-		attempts
-	});
-}
-
-//#endregion
-//#region src/internal/execution/parse.utils.ts
-/** Default `parseJson`: `JSON.parse` wrapped in try/catch, returning `undefined` on failure. */
-function defaultParseJson(content) {
-	try {
-		return JSON.parse(content);
-	} catch {
-		return void 0;
-	}
-}
-
-//#endregion
-//#region src/internal/execution/wire.utils.ts
-/** Translates app-facing `ToolDefinition[]` into the OpenAI-shaped wire tools array. */
-function toWireTools(tools) {
-	return tools.map((tool) => ({
-		type: "function",
-		function: {
-			name: tool.name,
-			description: tool.description,
-			parameters: tool.parameters
-		}
-	}));
-}
-/** Translates app-facing `ToolCall[]` (e.g. from a replayed assistant turn) into wire tool_calls. */
-function toWireToolCalls(toolCalls) {
-	return toolCalls.map((tc) => ({
-		id: tc.id,
-		type: "function",
-		function: {
-			name: tc.name,
-			arguments: JSON.stringify(tc.arguments ?? {})
-		}
-	}));
-}
-/**
-* Parses the provider's wire-shaped `tool_calls` back into VernLLM's
-* `ToolCall[]`. Malformed argument JSON is a `'parse'` error, same
-* convention as malformed JSON response bodies elsewhere in VernLLM.
-*/
-function parseWireToolCalls(wireToolCalls) {
-	return wireToolCalls.map((wc) => {
-		let parsedArgs;
-		try {
-			parsedArgs = wc.function.arguments.trim() ? JSON.parse(wc.function.arguments) : {};
-		} catch {
-			throw new LLMError(`Invalid JSON arguments for tool call "${wc.function.name}"`, "parse", { code: "tool_arguments_parse_failed" });
-		}
-		return {
-			id: wc.id,
-			name: wc.function.name,
-			arguments: parsedArgs
-		};
-	});
-}
-
-//#endregion
-//#region src/internal/execution/requestBuilder.ts
-/**
-* 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
-* on execution: history alternation, duplicate/empty tool lists,
-* `toolChoice` naming a real tool. All deterministic on the call site's
-* own input and never touch the network, so every throw here is
-* `type: 'invalid_params'`, not `'validation'` (which is reserved for the
-* model/provider's own response failing a contract check). Has no
-* knowledge of retry, timeouts, or the breaker, only
-* the three defaults a `FallbackTarget` can override per-target (see the
-* `defaultMaxTokens`/`defaultTemperature` overrides in the fallback
-* design), which is what keeps it separable from `CallExecutor`.
-*/
-var RequestBuilder = class {
-	model;
-	defaultMaxTokens;
-	defaultTemperature;
-	constructor(options) {
-		this.model = options.model;
-		this.defaultMaxTokens = options.defaultMaxTokens;
-		this.defaultTemperature = options.defaultTemperature;
-	}
-	/** 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 temperature = params.temperature === void 0 ? this.defaultTemperature : params.temperature;
-		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();
-			const duplicates = new Set();
-			for (const tool of tools) {
-				if (seen.has(tool.name)) duplicates.add(tool.name);
-				seen.add(tool.name);
-			}
-			if (duplicates.size) throw new LLMError(`\`tools\` has duplicate name(s): [${[...duplicates].join(", ")}]. Tool names must be unique.`, "invalid_params", {
-				code: "duplicate_tool_names",
-				issues: { names: [...duplicates] }
-			});
-		}
-		if (toolChoice && !tools) throw new LLMError("`toolChoice` was set without `tools`. There is nothing for it to choose between. Set `tools`, or remove `toolChoice`.", "invalid_params");
-		if (tools && typeof toolChoice === "object" && !tools.some((t) => t.name === toolChoice.name)) throw new LLMError(`toolChoice names "${toolChoice.name}", which is not in \`tools\` ([${tools.map((t) => t.name).join(", ")}]).`, "invalid_params", {
-			code: "unknown_tool_choice",
-			issues: {
-				requested: toolChoice.name,
-				available: tools.map((t) => t.name)
-			}
-		});
-		const jsonMode = params.jsonMode ?? (tools ? false : true);
-		const useJson = jsonMode || 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);
-		const request = {
-			model,
-			...temperature !== null ? { temperature } : {},
-			max_tokens: maxTokens,
-			...responseFormat ? { response_format: responseFormat } : {},
-			...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
-			...tools ? { tools: toWireTools(tools) } : {},
-			...tools ? { tool_choice: this.buildWireToolChoice(toolChoice) } : {},
-			messages: [
-				...systemPrompt ? [{
-					role: "system",
-					content: systemPrompt
-				}] : [],
-				...history.flatMap((turn) => this.turnToWireMessages(turn)),
-				{
-					role: "user",
-					content: userContent
-				}
-			]
-		};
-		return {
-			useJson,
-			model,
-			request
-		};
-	}
-	/**
-	* Validates `history` alternates user/assistant turns, since providers
-	* like Anthropic/Gemini reject or mishandle consecutive same-role turns.
-	*/
-	validateHistory(history) {
-		let previousTurn;
-		for (const [index, turn] of history.entries()) {
-			if (turn.role === "tool") {
-				if (previousTurn?.role !== "assistant" || !previousTurn.toolCalls?.length) throw new LLMError(`history[${index}] is a "tool" turn, but must immediately follow an "assistant" turn that requested tools`, "invalid_params");
-				if (!turn.toolResults?.length) throw new LLMError(`history[${index}] is a "tool" turn but has no toolResults`, "invalid_params");
-				const requestedIds = new Set(previousTurn.toolCalls.map((tc) => tc.id));
-				const resultIds = turn.toolResults.map((tr) => tr.toolCallId);
-				const unknownIds = resultIds.filter((id) => !requestedIds.has(id));
-				if (unknownIds.length) throw new LLMError(`history[${index}].toolResults references unknown toolCallId(s) [${unknownIds.join(", ")}]`, "invalid_params", {
-					code: "unknown_tool_result_ids",
-					issues: {
-						historyIndex: index,
-						ids: unknownIds
-					}
-				});
-				const seenIds = new Set();
-				const duplicateIds = new Set();
-				for (const id of resultIds) {
-					if (seenIds.has(id)) duplicateIds.add(id);
-					seenIds.add(id);
-				}
-				if (duplicateIds.size) throw new LLMError(`history[${index}].toolResults has duplicate toolCallId(s) [${[...duplicateIds].join(", ")}]`, "invalid_params", {
-					code: "duplicate_tool_result_ids",
-					issues: {
-						historyIndex: index,
-						ids: [...duplicateIds]
-					}
-				});
-				const missingIds = [...requestedIds].filter((id) => !resultIds.includes(id));
-				if (missingIds.length) throw new LLMError(`history[${index}] is missing toolResults for toolCallId(s) [${missingIds.join(", ")}]`, "invalid_params", {
-					code: "missing_tool_results",
-					issues: {
-						historyIndex: index,
-						ids: missingIds
-					}
-				});
-			} else {
-				if (turn.role === previousTurn?.role) throw new LLMError(`history must alternate user/assistant turns: consecutive "${turn.role}" turns at history[${index - 1}] and history[${index}]`, "invalid_params");
-				if (previousTurn?.role === "assistant" && previousTurn.toolCalls?.length) throw new LLMError(`history[${index}] follows an assistant tool request without tool results`, "invalid_params");
-			}
-			previousTurn = turn;
-		}
-		if (previousTurn?.role === "assistant" && previousTurn.toolCalls?.length) throw new LLMError("The last entry in history is an assistant tool request without tool results", "invalid_params");
-		if (previousTurn?.role === "user") throw new LLMError("The last entry in history is a \"user\" turn, which would collide with the current userContent turn.", "invalid_params");
-	}
-	/** Maps VernLLM's app-facing `ToolChoice` onto the OpenAI-shaped wire `tool_choice`. */
-	buildWireToolChoice(toolChoice) {
-		if (!toolChoice || toolChoice === "auto") return "auto";
-		if (toolChoice === "none" || toolChoice === "required") return toolChoice;
-		return {
-			type: "function",
-			function: { name: toolChoice.name }
-		};
-	}
-	/**
-	* Expands one `ConversationTurn` into one or more wire messages. Plain
-	* user/assistant turns map 1:1. An assistant turn with `toolCalls` maps
-	* to an assistant message carrying wire-shaped `tool_calls`. A `'tool'`
-	* turn expands into one wire `tool` message per `toolResult`, since
-	* OpenAI-shaped wire format wants one message per tool_call_id.
-	*/
-	turnToWireMessages(turn) {
-		if (turn.role === "tool") return (turn.toolResults ?? []).map((tr) => ({
-			role: "tool",
-			tool_call_id: tr.toolCallId,
-			content: typeof tr.content === "string" ? tr.content : JSON.stringify(tr.content ?? null),
-			...tr.isError ? { is_error: true } : {}
-		}));
-		if (turn.role === "assistant" && turn.toolCalls?.length) return [{
-			role: "assistant",
-			...turn.content ? { content: turn.content } : {},
-			tool_calls: toWireToolCalls(turn.toolCalls)
-		}];
-		return [{
-			role: turn.role,
-			content: turn.content ?? ""
-		}];
-	}
-	/**
-	* Chooses the response format: a provider-native `jsonSchema` takes
-	* priority when supplied (constrains generation directly), otherwise
-	* falls back to the looser `json_object` mode when JSON output is
-	* requested, or no format at all for plain text responses.
-	*/
-	buildResponseFormat(jsonSchema, useJson) {
-		if (jsonSchema) return {
-			type: "json_schema",
-			json_schema: {
-				name: jsonSchema.name,
-				schema: jsonSchema.schema,
-				strict: jsonSchema.strict ?? true,
-				description: jsonSchema.description
-			}
-		};
-		return useJson ? { type: "json_object" } : void 0;
-	}
-};
-
-//#endregion
-//#region src/internal/execution/streamAccumulator.ts
-/**
-* The streaming accumulator: wraps the raw `WireStreamChunk` iterator in
-* an async generator that yields translated `StreamChunk`s to the caller
-* live, as they arrive, with no per-chunk timeout and no bound on total
-* duration, and accumulates text/tool-call deltas internally so that
-* `finalize` can produce `finalResult` once the stream completes.
-*
-* Two separate try/catches: the iteration loop's catch handles errors
-* the transport itself throws, which aren't normalized yet, so that
-* happens here, alongside the one `onStreamFailure` call for them. The
-* second catch, around `finalize`, does not re-normalize or re-report,
-* since `finalize`'s caller (`finalizeResponse`) already does both
-* internally.
-*/
-function buildStreamResult(iterator, first, options) {
-	const { requestId, model, providerName, isFallback, chunkIdleTimeoutMs, streamController, logger, signal } = options;
-	let resolveFinal;
-	let rejectFinal;
-	const finalResult = new Promise((resolve, reject) => {
-		resolveFinal = resolve;
-		rejectFinal = reject;
-	});
-	finalResult.catch(() => {});
-	const MAX_BUFFERED_CHUNKS = 1e4;
-	const buffered = [];
-	const pending = [];
-	let streamDone = false;
-	let streamError;
-	let hasLoggedEviction = false;
-	const push = (chunk) => {
-		const waiter = pending.shift();
-		if (waiter) {
-			waiter.resolve({
-				done: false,
-				value: chunk
-			});
-			return;
-		}
-		buffered.push(chunk);
-		if (buffered.length > MAX_BUFFERED_CHUNKS * 2) {
-			if (!hasLoggedEviction) {
-				hasLoggedEviction = true;
-				logger.warn(`[VernLLM] stream chunk buffer exceeded cap (${MAX_BUFFERED_CHUNKS}), evicting ${buffered.length - MAX_BUFFERED_CHUNKS} oldest chunk(s); buffered=${buffered.length}. The chunks iterable was never read (or fell far behind) for this stream.`);
-			}
-			buffered.splice(0, buffered.length - MAX_BUFFERED_CHUNKS);
-		}
-	};
-	const finish = () => {
-		streamDone = true;
-		for (const waiter of pending.splice(0)) waiter.resolve({
-			done: true,
-			value: void 0
-		});
-	};
-	const fail = (error) => {
-		streamDone = true;
-		streamError = error;
-		for (const waiter of pending.splice(0)) waiter.reject(error);
-	};
-	const chunks = { [Symbol.asyncIterator]() {
-		return { next() {
-			if (buffered.length) return Promise.resolve({
-				done: false,
-				value: buffered.shift()
-			});
-			if (streamDone) return streamError ? Promise.reject(streamError) : Promise.resolve({
-				done: true,
-				value: void 0
-			});
-			return new Promise((resolve, reject) => {
-				pending.push({
-					resolve,
-					reject
-				});
-			});
-		} };
-	} };
-	const toolCallAcc = new Map();
-	let textAcc = "";
-	let usage;
-	(async () => {
-		try {
-			let result = first;
-			while (!result.done) {
-				const wireChunk = result.value;
-				if (wireChunk.type === "ping") {} else if (wireChunk.type === "text-delta") {
-					textAcc += wireChunk.delta;
-					push({
-						type: "text-delta",
-						delta: wireChunk.delta
-					});
-				} else if (wireChunk.type === "tool_call_delta") {
-					const entry = toolCallAcc.get(wireChunk.index) ?? { args: "" };
-					entry.id ??= wireChunk.id;
-					entry.name ??= wireChunk.name;
-					entry.args += wireChunk.argumentsDelta ?? "";
-					toolCallAcc.set(wireChunk.index, entry);
-					push({
-						type: "tool_call_delta",
-						index: wireChunk.index,
-						id: wireChunk.id,
-						name: wireChunk.name,
-						argsDelta: wireChunk.argumentsDelta,
-						complete: wireChunk.complete
-					});
-				} else if (wireChunk.type === "usage") {
-					usage = {
-						promptTokens: wireChunk.usage.prompt_tokens ?? 0,
-						completionTokens: wireChunk.usage.completion_tokens ?? 0,
-						totalTokens: wireChunk.usage.total_tokens ?? 0,
-						requestId,
-						model,
-						provider: providerName,
-						usedFallback: isFallback
-					};
-					push({
-						type: "usage",
-						usage
-					});
-				}
-				result = await withChunkIdleTimeout(() => iterator.next(), chunkIdleTimeoutMs, () => streamController.abort(), logger);
-			}
-		} catch (error) {
-			try {
-				await iterator.return?.();
-			} catch {}
-			streamController.abort();
-			const normalized = normalizeError(error, signal);
-			try {
-				options.onStreamFailure(normalized, usage);
-			} catch {}
-			fail(normalized);
-			rejectFinal(normalized);
-			return;
-		}
-		finish();
-		try {
-			options.onStreamSuccess(usage);
-		} catch {}
-		try {
-			const wireToolCalls = toolCallAcc.size ? [...toolCallAcc.entries()].sort(([indexA], [indexB]) => indexA - indexB).map(([, entry]) => ({
-				id: entry.id ?? "",
-				type: "function",
-				function: {
-					name: entry.name ?? "",
-					arguments: entry.args
-				}
-			})) : void 0;
-			const finalized = options.finalize(textAcc, wireToolCalls, usage);
-			resolveFinal(finalized);
-		} catch (error) {
-			rejectFinal(error);
-		}
-	})();
-	return {
-		chunks,
-		finalResult
-	};
-}
-
-//#endregion
-//#region src/internal/execution/callExecutor.ts
-/**
-* 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
-* owns the fallback loop and caching on top.
-*/
-var CallExecutor = class {
-	maxRetries;
-	timeoutMs;
-	chunkIdleTimeoutMs;
-	baseDelayMs;
-	nonRetryableStatus;
-	parseJson;
-	logger;
-	redact;
-	onUsage;
-	onUsageFailure;
-	reportEvent;
-	breaker;
-	limiter;
-	isFallback;
-	requestBuilder;
-	constructor(providerName, client, model, options) {
-		this.providerName = providerName;
-		this.client = client;
-		this.model = model;
-		this.maxRetries = options.maxRetries;
-		this.timeoutMs = options.timeoutMs;
-		this.chunkIdleTimeoutMs = options.chunkIdleTimeoutMs;
-		this.baseDelayMs = options.baseDelayMs;
-		this.nonRetryableStatus = options.nonRetryableStatus;
-		this.parseJson = options.parseJson ?? defaultParseJson;
-		this.logger = options.logger;
-		this.redact = options.redact;
-		this.onUsage = options.onUsage;
-		this.onUsageFailure = options.onUsageFailure;
-		this.reportEvent = makeEventReporter(options.onEvent, this.logger);
-		this.breaker = options.breaker;
-		this.limiter = options.limiter;
-		this.isFallback = options.isFallback ?? false;
-		this.requestBuilder = new RequestBuilder({
-			model,
-			defaultMaxTokens: options.defaultMaxTokens,
-			defaultTemperature: options.defaultTemperature
-		});
-	}
-	getCircuitState(model) {
-		return this.breaker?.getState(model);
-	}
-	/** Whether this target's breaker tracks failures per model. `false` if no breaker is configured. */
-	get isolateByModel() {
-		return this.breaker?.isolateByModel ?? false;
-	}
-	/** Manually opens this target's circuit breaker, if one is configured. No-op otherwise. */
-	openCircuit(model) {
-		this.breaker?.open(model);
-	}
-	/** Manually closes this target's circuit breaker, if one is configured. No-op otherwise. */
-	closeCircuit(model) {
-		this.breaker?.close(model);
-	}
-	/**
-	* Throws if the breaker is open for this target/model, exactly like the
-	* check `run`/`runStream` used to make internally. Exposed so `VernLLM`
-	* can gate on it before reserving usage, avoiding a reserve-then-refund
-	* round trip on a call that was never going to be attempted. `assertClosed`
-	* has a stateful side effect (claiming a half-open trial slot), so it must
-	* run exactly once per logical call: `run`/`runStream` no longer call it
-	* themselves, this is now the only call site.
-	*/
-	assertBreakerClosed(model) {
-		this.breaker?.assertClosed(model ?? this.model);
-	}
-	/**
-	* Runs a single logical call against this target: retry with backoff,
-	* normalized error on exhaustion. Mirrors the old `VernLLM.call`'s
-	* non-streaming branch, minus cache/usage-reservation and the breaker
-	* check, which stay one layer up since they aren't per-target concerns
-	* (see `assertBreakerClosed`).
-	*/
-	async run(params, requestId, onAttempt) {
-		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);
-		} catch (error) {
-			const normalized = normalizeError(error, params.signal, attempts.length > 0 ? attempts : void 0);
-			if (this.countsTowardBreaker(normalized)) this.breaker?.recordFailure(model);
-			this.logger.debug(`[VernLLM:${requestId}] error:\n${this.redactText(describeError(error))}`);
-			throw normalized;
-		}
-	}
-	/** Streaming counterpart to `run`. Mirrors the old streaming branch of `VernLLM.call`. */
-	async runStream(params, requestId, onAttempt) {
-		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);
-		} catch (error) {
-			const normalized = normalizeError(error, params.signal, attempts.length > 0 ? attempts : void 0);
-			if (this.countsTowardBreaker(normalized)) this.breaker?.recordFailure(model);
-			this.logger.debug(`[VernLLM:${requestId}] stream-open error:\n${this.redactText(describeError(error))}`);
-			throw normalized;
-		}
-	}
-	/**
-	* Performs a single attempt: builds the request (translating `tools` to
-	* wire shape when present), dispatches it with a timeout, and shapes the
-	* response into `T` or a `CallWithToolsResult<T>` when `params.tools` was
-	* 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) {
-		const { useJson, model, request } = this.requestBuilder.build(params);
-		let release;
-		if (this.limiter) {
-			const acquired = await this.limiter.acquire(this.limiter.estimate(request), params.signal);
-			release = acquired.release;
-			if (acquired.waitedMs > 0) this.reportEvent({
-				kind: "rate_limited",
-				requestId,
-				provider: this.providerName,
-				model,
-				waitedMs: acquired.waitedMs,
-				reason: acquired.reason ?? "rpm"
-			});
-		}
-		try {
-			const response = await withTimeout((attemptSignal) => this.client.chat.completions.create(request, { signal: attemptSignal }), this.timeoutMs, params.signal);
-			const usage = this.extractUsage(response, requestId, model);
-			release?.(this.actualTokensFor(usage));
-			release = void 0;
-			const rawContent = response.choices?.[0]?.message?.content;
-			const wireToolCalls = response.choices?.[0]?.message?.tool_calls;
-			return this.finalizeResponse(rawContent, wireToolCalls, params, useJson, model, usage, requestId, attempt);
-		} finally {
-			release?.();
-		}
-	}
-	/** Applies `redact` (if configured); otherwise returns `text` unchanged. */
-	redactText(text) {
-		return this.redact ? this.redact(text) : text;
-	}
-	/**
-	* Applies `redact` (if configured) to whatever the debug log is about
-	* to show: real content when there is any, otherwise the tool-call
-	* placeholder, which carries no user data and passes through
-	* `redact` unchanged in practice but is included for a caller whose
-	* `redact` does something structural (e.g. adding a marker) rather
-	* than just scrubbing PII.
-	*/
-	redactedOutput(content, wireToolCalls) {
-		return this.redactText(content ?? `[${wireToolCalls?.length ?? 0} tool call(s)]`);
-	}
-	/**
-	* Shapes a fully-arrived response (content and/or tool_calls, already
-	* extracted from the provider's payload) into `T` or a
-	* `CallWithToolsResult<T>`. Reused by the streaming path once it has
-	* buffered the full text/tool-call deltas, so there's no separate
-	* parsing/validation logic for streaming.
-	*
-	* Normalizes and reports usage failure on error itself, so every caller
-	* gets identical error handling without duplicating it.
-	*/
-	finalizeResponse(rawContent, wireToolCalls, params, useJson, model, usage, requestId, attempt) {
-		try {
-			const content = rawContent?.trim();
-			if (!content && !wireToolCalls?.length) throw new LLMError("Empty LLM response", "api", { code: "empty_response" });
-			this.logger.debug(`[VernLLM:${requestId}] output:\n${this.redactedOutput(content, wireToolCalls).slice(0, 800)}`);
-			if (wireToolCalls?.length) {
-				if (!params.tools) throw new LLMError("Provider returned tool_calls but no `tools` were sent with this call.", "validation", { code: "unexpected_tool_calls" });
-				if (params.toolChoice === "none") throw new LLMError("Provider returned tool_calls despite toolChoice: 'none'.", "validation", { code: "tool_choice_none_violated" });
-				const toolCalls = parseWireToolCalls(wireToolCalls);
-				this.validateToolCallArguments(toolCalls, params.tools);
-				this.breaker?.recordSuccess(model);
-				this.reportUsage(usage);
-				return {
-					type: "tool_calls",
-					toolCalls,
-					...content ? { content } : {}
-				};
-			}
-			const textContent = content ?? "";
-			if (!useJson) {
-				this.breaker?.recordSuccess(model);
-				this.reportUsage(usage);
-				return params.tools ? {
-					type: "content",
-					content: textContent
-				} : textContent;
-			}
-			const result = this.parseAndValidate(textContent, params.schema);
-			this.breaker?.recordSuccess(model);
-			this.reportUsage(usage);
-			return params.tools ? {
-				type: "content",
-				content: result
-			} : result;
-		} catch (error) {
-			const normalized = normalizeError(error, params.signal);
-			if (usage && normalized.type !== "aborted") this.reportUsageFailure(usage, normalized, attempt);
-			throw normalized;
-		}
-	}
-	/**
-	* Opens a stream for a single attempt: builds the request exactly like
-	* `executeCall`, then requires `createStream` on the client (a clear
-	* `validation` error if the adapter doesn't support it). The timeout
-	* wraps stream construction and the first `.next()` together, not just
-	* construction: calling an `async function*` returns an iterator
-	* synchronously without running its body until `.next()` is first
-	* invoked, so timing only construction would time an operation that's
-	* always instant, not the actual connection. Both are folded into a
-	* single `withTimeout` so the same abort signal reaches whatever the
-	* adapter's `createStream` uses internally for its first network
-	* round-trip.
-	*
-	* Circuit-breaker success is recorded once the stream fully completes,
-	* 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) {
-		const { useJson, model, request } = this.requestBuilder.build(params);
-		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",
-			issues: { capability: "createStream" }
-		});
-		const createStream = completions.createStream.bind(completions);
-		let release;
-		if (this.limiter) {
-			const acquired = await this.limiter.acquire(this.limiter.estimate(request), params.signal);
-			release = acquired.release;
-			if (acquired.waitedMs > 0) this.reportEvent({
-				kind: "rate_limited",
-				requestId,
-				provider: this.providerName,
-				model,
-				waitedMs: acquired.waitedMs,
-				reason: acquired.reason ?? "rpm"
-			});
-		}
-		const streamController = new AbortController();
-		const combinedExternal = params.signal ? AbortSignal.any([params.signal, streamController.signal]) : streamController.signal;
-		try {
-			const { iterator, first } = await withTimeout(async (attemptSignal) => {
-				const streamIterator = createStream(request, { signal: attemptSignal })[Symbol.asyncIterator]();
-				const firstResult = await streamIterator.next();
-				return {
-					iterator: streamIterator,
-					first: firstResult
-				};
-			}, this.timeoutMs, combinedExternal);
-			if (first.done) throw new LLMError("Empty LLM response", "api");
-			const releaseAtOpen = release;
-			const result = buildStreamResult(iterator, first, {
-				requestId,
-				model,
-				providerName: this.providerName,
-				isFallback: this.isFallback,
-				chunkIdleTimeoutMs: params.chunkIdleTimeoutMs ?? this.chunkIdleTimeoutMs,
-				streamController,
-				logger: this.logger,
-				signal: params.signal,
-				onStreamSuccess: (usage) => {
-					this.breaker?.recordSuccess(model);
-					releaseAtOpen?.(this.actualTokensFor(usage));
-				},
-				onStreamFailure: (normalized, usage) => {
-					if (normalized.type === "timeout") this.breaker?.recordFailure(model);
-					if (usage && normalized.type !== "aborted") this.reportUsageFailure(usage, normalized, attempt, true);
-					releaseAtOpen?.(this.actualTokensFor(usage));
-				},
-				finalize: (textAcc, wireToolCalls, usage) => this.finalizeResponse(textAcc, wireToolCalls, params, useJson, model, usage, requestId, attempt)
-			});
-			release = void 0;
-			return result;
-		} finally {
-			release?.();
-		}
-	}
-	/**
-	* Checks every `ToolCall` against the `tools` that were offered, catching
-	* a hallucinated tool name and a duplicate call id before either reaches
-	* the application's dispatch table, then runs each tool's
-	* `argumentsSchema`, if present.
-	*
-	* Contract failures (unknown name, duplicate id) are collected across
-	* every call and thrown together as one `type: 'validation'` error with
-	* `issues: ToolIssue[]`, since retrying a request that already has these
-	* errors cannot help (excluded from retry by `type`) and a caller fixing
-	* them wants to see every one, not just the first. Schema failures keep
-	* the original single-error, `type: 'validation'` shape rather than being
-	* folded into the aggregate, since they're a distinct failure kind from
-	* the contract failures above.
-	*/
-	validateToolCallArguments(toolCalls, tools) {
-		const known = new Map(tools.map((t) => [t.name, t]));
-		const seenIds = new Set();
-		const toolIssues = [];
-		for (const call of toolCalls) {
-			if (seenIds.has(call.id)) toolIssues.push({
-				name: call.name,
-				toolCallId: call.id,
-				code: "duplicate_tool_call_id"
-			});
-			seenIds.add(call.id);
-			if (!known.has(call.name)) toolIssues.push({
-				name: call.name,
-				toolCallId: call.id,
-				code: "unknown_tool"
-			});
-		}
-		if (toolIssues.length > 0) {
-			const unknownTool = toolIssues.find((i) => i.code === "unknown_tool");
-			const primary = unknownTool ? `Model requested tool "${unknownTool.name}", which was not in the tools offered ([${[...known.keys()].join(", ")}]).` : `Duplicate tool call id "${toolIssues[0].toolCallId}" in the model's response.`;
-			const message = toolIssues.length > 1 ? `${primary} (${toolIssues.length} tool call issues total, see error.issues.)` : primary;
-			throw new LLMError(message, "validation", {
-				code: unknownTool ? "unknown_tool" : "duplicate_tool_call_id",
-				issues: toolIssues
-			});
-		}
-		for (const call of toolCalls) {
-			const definition = known.get(call.name);
-			if (!definition?.argumentsSchema) continue;
-			const result = definition.argumentsSchema.safeParse(call.arguments);
-			if (!result.success) throw new LLMError(`Arguments for tool call "${call.name}" failed validation`, "validation", { issues: result.error });
-		}
-	}
-	/**
-	* Runs `fn`, retrying with backoff according to `shouldRetry`. When
-	* `attempts` is given, every failed attempt that is actually followed by
-	* a retry is recorded, in order. This mirrors `LLMError.attempts`'s
-	* contract: every attempt made before this error was thrown. The
-	* terminal failure is never pushed since it isn't a prior attempt, it
-	* is the error being thrown. `attempts` stays empty when nothing was
-	* retried, so no separate bookkeeping is needed at the call sites.
-	* Each failure is recorded as a snapshot (`LLMError.toSnapshot()`),
-	* not the live `LLMError`, per `RetryAttempt`'s contract.
-	*/
-	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()
-			});
-		}
-		throw lastError;
-	}
-	/**
-	* Pulls `TokenUsage` out of a raw response, if the provider reported it.
-	* Extraction doesn't depend on what happens to the response afterward, so
-	* a malformed body can still yield usage if the provider's usage block
-	* itself came through intact.
-	*/
-	extractUsage(response, requestId, model) {
-		if (!response.usage) return void 0;
-		return {
-			promptTokens: response.usage.prompt_tokens ?? 0,
-			completionTokens: response.usage.completion_tokens ?? 0,
-			totalTokens: response.usage.total_tokens ?? 0,
-			requestId,
-			model,
-			provider: this.providerName,
-			usedFallback: this.isFallback
-		};
-	}
-	/**
-	* The token count to reconcile the rate limiter against for a finished
-	* attempt: `totalTokens` when reported, otherwise the sum of prompt and
-	* completion tokens, matching `reportUsageFailure`'s own fallback below
-	* for a hand-rolled client that reports the parts but omits the total.
-	*/
-	actualTokensFor(usage) {
-		if (!usage) return void 0;
-		return usage.totalTokens || usage.promptTokens + usage.completionTokens;
-	}
-	/** Reports token usage for a successful call, swallowing and logging any error `onUsage` throws. */
-	reportUsage(usage) {
-		if (!usage || !this.onUsage) return;
-		try {
-			this.onUsage(usage);
-		} catch (error) {
-			this.logger.error("[VernLLM] onUsage failed", { message: error instanceof Error ? error.message : "unknown" });
-		}
-	}
-	/**
-	* Reports token usage spent on an attempt that then failed, so it isn't
-	* dropped alongside the error. Covers any error thrown after usage
-	* extraction, since all of them happen only after a response (real
-	* spend) already arrived. Swallows and logs any error `onUsageFailure`
-	* itself throws.
-	*/
-	reportUsageFailure(usage, error, attempt, terminal = false) {
-		const displayTokens = usage.totalTokens || usage.promptTokens + usage.completionTokens;
-		const attemptText = terminal ? "mid-stream failure (terminal, no further attempts)" : `attempt ${attempt + 1}/${this.maxRetries + 1}`;
-		this.logger.warn(`[VernLLM:${usage.requestId}] usage failure, ${attemptText}: type=${error.type} tokens=${displayTokens}`);
-		if (!this.onUsageFailure) return;
-		try {
-			this.onUsageFailure(usage, error);
-		} catch (hookError) {
-			this.logger.error("[VernLLM] onUsageFailure failed", { message: hookError instanceof Error ? hookError.message : "unknown" });
-		}
-	}
-	/** Parses response content as JSON and validates it against `schema` when supplied. */
-	parseAndValidate(content, schema) {
-		let parsed;
-		try {
-			parsed = this.parseJson(content);
-		} catch {
-			throw new LLMError("Invalid JSON response", "parse");
-		}
-		if (parsed === null || parsed === void 0) throw new LLMError("Invalid JSON response", "parse");
-		if (!schema) return parsed;
-		const result = schema.safeParse(parsed);
-		if (!result.success) throw new LLMError("Schema validation failed", "validation", { issues: result.error });
-		return result.data;
-	}
-	/**
-	* Waits out the backoff delay for a retry attempt, honoring a
-	* Retry-After header on the failed attempt's error when present.
-	* Both Retry-After and plain exponential backoff are capped at the same
-	* max delay (see `DEFAULT_MAX_DELAY_MS` in `retry.utils.ts`).
-	*/
-	async recoverDelay(requestId, model, attempt, error, signal) {
-		const retryAfterMs = extractRetryAfterMs(error);
-		const delay = retryAfterMs ?? getBackoffDelay(this.baseDelayMs, attempt);
-		const retryAfterHonored = retryAfterMs !== void 0;
-		this.logger.warn(`[VernLLM:${requestId}] recovery attempt ${attempt}/${this.maxRetries}, waiting ${Math.ceil(delay)}ms` + (retryAfterHonored ? " (honoring Retry-After)" : ""));
-		this.reportEvent({
-			kind: "retry",
-			requestId,
-			provider: this.providerName,
-			model,
-			attempt,
-			maxRetries: this.maxRetries,
-			delayMs: delay,
-			retryAfterHonored,
-			error: normalizeError(error, signal)
-		});
-		await waitForRetry(delay, signal);
-	}
-	/** Decides whether a failed attempt is worth retrying. */
-	shouldRetry(error, signal) {
-		if (signal?.aborted) return false;
-		if (error instanceof LLMError && !error.retryable) return false;
-		const status = extractStatus(error);
-		return !(status !== void 0 && this.nonRetryableStatus.includes(status));
-	}
-	/**
-	* Decides whether a failed attempt should count toward the circuit
-	* breaker's failure threshold. A model hallucinating a tool name,
-	* reusing a call id, or a provider ignoring `toolChoice: 'none'` isn't
-	* the provider being unhealthy, it's a model/provider response defect
-	* that will very likely recur regardless of provider health, so it
-	* shouldn't push a healthy provider's circuit toward opening. Same for
-	* a caller-input bug or a local rate-limit rejection: neither ever
-	* reached the provider at all. This is exactly what `LLMError.retryable`
-	* already excludes, so this defers to it directly.
-	*/
-	countsTowardBreaker(error) {
-		return error.retryable;
-	}
-};
-
-//#endregion
-//#region src/internal/logger.utils.ts
-/**
-* Wraps a `Logger` so a throwing implementation can never break the call
-* it's trying to describe. `logger` is user-supplied (`VernLLMOptions.logger`),
-* so a custom logger that ships to a file, Datadog, etc. can throw for
-* reasons unrelated to VernLLM. Wrap once at construction so every
-* downstream `this.logger.warn(...)` call stays as-is and is safe by
-* construction, instead of guarding each call site individually.
-*/
-function createSafeLogger(logger) {
-	return {
-		debug: safe(logger, "debug"),
-		warn: safe(logger, "warn"),
-		error: safe(logger, "error")
-	};
-}
-function safe(logger, method) {
-	const fn = logger[method].bind(logger);
-	return (...args) => {
-		try {
-			swallowRejection(fn(...args));
-		} catch {}
-	};
-}
-function isPromiseLike(value) {
-	return typeof value?.then === "function";
-}
-function swallowRejection(result) {
-	if (isPromiseLike(result)) Promise.resolve(result).catch(() => {});
-}
-
-//#endregion
-//#region src/logger.ts
-/**
-* Default logger. `debug` is gated by the `debug` option on VernLLM
-* warn/error always fire since they indicate real problems (retries, cache failures)
-*/
-var ConsoleLogger = class {
-	constructor(debugEnabled) {
-		this.debugEnabled = debugEnabled;
-	}
-	debug(message) {
-		if (this.debugEnabled) console.debug(message);
-	}
-	warn(message) {
-		console.warn(message);
-	}
-	error(message, meta) {
-		console.error(message, meta ?? "");
-	}
-};
-
-//#endregion
-//#region src/rateLimit.ts
-/** Default `estimateTokens`: chars/4 over every message's content, plus the requested `max_tokens`. */
-function defaultEstimateTokens(request) {
-	const messagesChars = request.messages.reduce((sum, message) => {
-		const content = message.content;
-		if (typeof content === "string") return sum + content.length;
-		if (content === void 0 || content === null) return sum;
-		try {
-			return sum + JSON.stringify(content).length;
-		} catch {
-			return sum;
-		}
-	}, 0);
-	return Math.ceil(messagesChars / 4) + (request.max_tokens ?? 0);
-}
-/**
-* A capacity that refills continuously. Used for requests per minute and
-* tokens per minute, where `refillPerMs` is `capacity / 60000`, and for
-* concurrency, where `refillPerMs` is 0 and every release calls
-* `give(1)` instead of relying on the clock.
-*/
-var TokenBucket = class {
-	available;
-	lastRefill = Date.now();
-	constructor(capacity, refillPerMs) {
-		this.capacity = capacity;
-		this.refillPerMs = refillPerMs;
-		this.available = capacity;
-	}
-	refill() {
-		if (this.refillPerMs === 0) return;
-		const now = Date.now();
-		const elapsedMs = now - this.lastRefill;
-		this.available = Math.min(this.capacity, this.available + Math.max(0, elapsedMs) * this.refillPerMs);
-		this.lastRefill = now;
-	}
-	/** Refills, then takes `amount` if available. Leaves the bucket untouched if it can't. */
-	tryTake(amount) {
-		this.refill();
-		if (this.available < amount) return false;
-		this.available -= amount;
-		return true;
-	}
-	/**
-	* Refills, then reports how many ms until this bucket could supply
-	* `amount`, assuming nothing else takes from it meanwhile. Returns 0 if
-	* it already can, `Infinity` if it never will on its own (a
-	* concurrency bucket, `refillPerMs === 0`, only frees via `give`).
-	*/
-	msUntilAvailable(amount) {
-		this.refill();
-		if (this.available >= amount) return 0;
-		if (this.refillPerMs === 0) return Infinity;
-		return (amount - this.available) / this.refillPerMs;
-	}
-	/**
-	* Gives capacity back. Not floored at 0: a bad token-usage estimate can
-	* push `available` negative, and it self-corrects on the next refill
-	* rather than being clamped away immediately. Only ceilinged at
-	* `capacity`, so a give can never overfill the bucket.
-	*/
-	give(amount) {
-		this.available = Math.min(this.capacity, this.available + amount);
-	}
-	/** The bucket's ceiling, e.g. so a request that could never fit can fail fast instead of queueing forever. */
-	getCapacity() {
-		return this.capacity;
-	}
-};
-/**
-* `setTimeout` silently clamps any delay above this (~24.8 days) instead
-* of erroring, so an uncapped delay derived from a very small
-* `requestsPerMinute`/`tokensPerMinute` could wrap around to firing
-* almost immediately instead of waiting. Mirrors the same guard in
-* `withTimeout`/`withChunkIdleTimeout`.
-*/
-const MAX_WAKE_DELAY_MS = 2147483647;
-/**
-* Per-target rate limiter. Up to three buckets (requests/min, tokens/min,
-* concurrency) behind one FIFO queue, so a large call isn't starved by a
-* stream of small ones. Any bucket omitted from `options` has infinite
-* capacity and never blocks.
-*/
-var RateLimiter = class {
-	requests;
-	tokens;
-	concurrency;
-	maxQueueMs;
-	maxQueueSize;
-	estimateTokensFn;
-	queue = [];
-	/**
-	* A single scheduled re-check for the head of the queue when it's
-	* blocked on a bucket that refills on its own clock (rpm/tpm), so a
-	* queue that nobody calls `acquire`/`release` on again isn't stuck
-	* forever waiting for an external trigger to re-drain it. Not needed
-	* for a concurrency block, which only clears via `release`.
-	*/
-	wakeTimer;
-	constructor(options) {
-		if (options.requestsPerMinute) this.requests = new TokenBucket(options.requestsPerMinute, options.requestsPerMinute / 6e4);
-		if (options.tokensPerMinute) this.tokens = new TokenBucket(options.tokensPerMinute, options.tokensPerMinute / 6e4);
-		if (options.maxConcurrent) this.concurrency = new TokenBucket(options.maxConcurrent, 0);
-		this.maxQueueMs = options.maxQueueMs ?? 3e4;
-		this.maxQueueSize = options.maxQueueSize ?? 0;
-		this.estimateTokensFn = options.estimateTokens ?? defaultEstimateTokens;
-	}
-	/** Pre-flight token estimate for a request, per the configured (or default) heuristic. */
-	estimate(request) {
-		return this.estimateTokensFn(request);
-	}
-	/**
-	* Waits for capacity in every configured bucket, then takes from each.
-	* The returned `release` gives the concurrency slot back and reconciles
-	* the token bucket against real usage; it must run in a `finally` block.
-	*/
-	async acquire(estimatedTokens, signal) {
-		if (signal?.aborted) throw new LLMError("LLM request aborted", "aborted");
-		if (!Number.isFinite(estimatedTokens) || estimatedTokens < 0) throw new LLMError(`estimatedTokens must be a finite, non-negative number, got ${String(estimatedTokens)}`, "invalid_params");
-		if (this.tokens && estimatedTokens > this.tokens.getCapacity()) throw new LLMError(`estimatedTokens (${estimatedTokens}) exceeds the configured tokensPerMinute capacity (${this.tokens.getCapacity()}); this call could never acquire capacity.`, "rate_limited", { code: "rate_limit_capacity_exceeded" });
-		if (this.queue.length === 0) {
-			const attempt = this.tryAcquireBuckets(estimatedTokens);
-			if (attempt.ok) return {
-				release: this.makeRelease(estimatedTokens),
-				waitedMs: 0
-			};
-			return this.enqueue(estimatedTokens, attempt.reason, signal);
-		}
-		if (this.maxQueueSize > 0 && this.queue.length >= this.maxQueueSize) throw this.queueFullError();
-		return this.enqueue(estimatedTokens, void 0, signal);
-	}
-	queueFullError() {
-		return new LLMError("Rate limit queue is full", "rate_limited", { code: "rate_limit_queue_full" });
-	}
-	enqueue(estimatedTokens, initialReason, signal) {
-		return new Promise((resolvePromise, rejectPromise) => {
-			const waiter = {
-				estimatedTokens,
-				enqueuedAt: Date.now(),
-				lastReason: initialReason,
-				resolve: (result) => {
-					cleanup();
-					resolvePromise(result);
-				},
-				reject: (error) => {
-					cleanup();
-					if (this.wakeTimer) {
-						clearTimeout(this.wakeTimer);
-						this.wakeTimer = void 0;
-					}
-					this.drain();
-					rejectPromise(error);
-				}
-			};
-			let queueTimer;
-			const onAbort = () => {
-				waiter.reject(new LLMError("LLM request aborted", "aborted"));
-			};
-			const cleanup = () => {
-				if (queueTimer) clearTimeout(queueTimer);
-				signal?.removeEventListener("abort", onAbort);
-				const index = this.queue.indexOf(waiter);
-				if (index !== -1) this.queue.splice(index, 1);
-			};
-			if (this.maxQueueMs > 0) queueTimer = setTimeout(() => {
-				waiter.reject(new LLMError("Rate limit queue timed out before capacity was available", "rate_limited", { code: "rate_limit_queue_timeout" }));
-			}, this.maxQueueMs);
-			signal?.addEventListener("abort", onAbort, { once: true });
-			this.queue.push(waiter);
-			this.drain();
-		});
-	}
-	/**
-	* Checks and takes from every configured bucket as one atomic unit: if
-	* any bucket lacks capacity, whatever was already taken from the
-	* earlier ones in this attempt is rolled back before reporting which
-	* bucket blocked.
-	*/
-	tryAcquireBuckets(estimatedTokens) {
-		const taken = [];
-		const take = (bucket, amount) => {
-			if (!bucket) return true;
-			if (!bucket.tryTake(amount)) return false;
-			taken.push({
-				bucket,
-				amount
-			});
-			return true;
-		};
-		if (!take(this.concurrency, 1)) return {
-			ok: false,
-			reason: "concurrency"
-		};
-		if (!take(this.requests, 1)) {
-			for (const entry of taken) entry.bucket.give(entry.amount);
-			return {
-				ok: false,
-				reason: "rpm"
-			};
-		}
-		if (!take(this.tokens, estimatedTokens)) {
-			for (const entry of taken) entry.bucket.give(entry.amount);
-			return {
-				ok: false,
-				reason: "tpm"
-			};
-		}
-		return { ok: true };
-	}
-	/** Drains the queue head first. Stops at the first waiter that still can't proceed, so no one is starved out of turn. */
-	drain() {
-		while (this.queue.length > 0) {
-			const waiter = this.queue[0];
-			const attempt = this.tryAcquireBuckets(waiter.estimatedTokens);
-			if (!attempt.ok) {
-				waiter.lastReason = attempt.reason;
-				this.scheduleWake(attempt.reason, waiter.estimatedTokens);
-				return;
-			}
-			const waitedMs = Date.now() - waiter.enqueuedAt;
-			waiter.resolve({
-				release: this.makeRelease(waiter.estimatedTokens),
-				waitedMs,
-				reason: waiter.lastReason
-			});
-		}
-	}
-	/**
-	* Schedules a one-shot re-check of the queue for whenever the bucket
-	* that's currently blocking the head waiter should next have enough
-	* capacity. A no-op for a concurrency block (only `release` can clear
-	* that) or while a wake is already pending.
-	*/
-	scheduleWake(reason, estimatedTokens) {
-		if (this.wakeTimer) return;
-		const ms = reason === "rpm" ? this.requests?.msUntilAvailable(1) : reason === "tpm" ? this.tokens?.msUntilAvailable(estimatedTokens) : void 0;
-		if (ms === void 0 || !Number.isFinite(ms)) return;
-		const delay = Math.min(Math.max(1, Math.ceil(ms)), MAX_WAKE_DELAY_MS);
-		this.wakeTimer = setTimeout(() => {
-			this.wakeTimer = void 0;
-			this.drain();
-		}, delay);
-	}
-	/**
-	* Builds the one-shot release closure for an acquired slot. Only the
-	* concurrency bucket is given back on release; the requests-per-minute
-	* bucket is a real spend that only recovers via its own refill, and the
-	* tokens bucket is reconciled against `actualTokens` rather than fully
-	* refunded, since real tokens really were spent.
-	*/
-	makeRelease(estimatedTokens) {
-		let released = false;
-		return (actualTokens) => {
-			if (released) return;
-			released = true;
-			this.concurrency?.give(1);
-			if (this.tokens && actualTokens !== void 0 && Number.isFinite(actualTokens)) this.tokens.give(estimatedTokens - actualTokens);
-			this.drain();
-		};
-	}
-};
-
-//#endregion
-//#region src/vernLLM.ts
-/**
-* A resilient layer around an LLM chat completions client. This is VernLLM!
-*
-* Adds retry with backoff and jitter, per-attempt timeouts, an optional
-* circuit breaker, JSON parsing with optional schema validation, usage
-* tracking, and an optional response cache. All configurable, all opt-in
-* beyond sensible defaults.
-*/
-var VernLLM = class {
-	logger;
-	/**
-	* One `CallExecutor` per provider target: index 0 is the primary,
-	* everything after it is a `fallback` target, in the order declared.
-	* Each owns its own request building, retry/timeout, circuit breaker,
-	* and rate limiter. `call()` walks this array in `runFallbackChain`,
-	* moving to the next entry only when `fallbackOn` says to.
-	*/
-	executors;
-	/** Decides whether a failed target is followed by the next one or the chain stops. See `VernLLMOptions['fallbackOn']`. */
-	fallbackOn;
-	/** Reports a `'fallback'` event when the chain moves to the next target. Shared `onEvent` plumbing, same as every executor's. */
-	reportEvent;
-	/**
-	* Owns cache key resolution, cache reads/writes, and in-flight
-	* coalescing for `cachedCall()`. Independent of `executor`: it only
-	* ever calls back into `this.call()` as an opaque function.
-	*/
-	cacheOrchestrator;
-	/**
-	* @param options Client, model, and tunables. Defaults: `maxRetries` 1,
-	* `timeoutMs` 25000, `baseDelayMs` 500, `defaultMaxTokens` 1000,
-	* `defaultTemperature` 0.2, `cache` an in-memory adapter,
-	* `nonRetryableStatus` `[400, 401, 403, 404, 422]`, `debug` false.
-	*/
-	constructor(options) {
-		this.logger = createSafeLogger(options.logger ?? new ConsoleLogger(options.debug ?? false));
-		const providerName = options.name ?? "primary";
-		this.cacheOrchestrator = new CacheOrchestrator(options.cache ?? new InMemoryCacheAdapter(), this.logger);
-		this.fallbackOn = options.fallbackOn ?? defaultFallbackOn;
-		this.reportEvent = makeEventReporter(options.onEvent, this.logger);
-		const primaryDefaultTemperature = options.defaultTemperature === void 0 ? .2 : options.defaultTemperature;
-		const primaryTarget = {
-			client: options.client,
-			model: options.model,
-			name: providerName,
-			maxRetries: options.maxRetries,
-			timeoutMs: options.timeoutMs,
-			chunkIdleTimeoutMs: options.chunkIdleTimeoutMs,
-			baseDelayMs: options.baseDelayMs,
-			defaultMaxTokens: options.defaultMaxTokens,
-			defaultTemperature: primaryDefaultTemperature,
-			nonRetryableStatus: options.nonRetryableStatus,
-			circuitBreaker: options.circuitBreaker,
-			rateLimit: options.rateLimit
-		};
-		const declaredFallbacks = Array.isArray(options.fallback) ? options.fallback : options.fallback ? [options.fallback] : [];
-		const targets = [primaryTarget, ...declaredFallbacks];
-		this.executors = targets.map((target, i) => {
-			const isFallback = i > 0;
-			const name = target.name ?? (isFallback ? `fallback[${i - 1}]` : providerName);
-			const breaker = buildCircuitBreaker(target.circuitBreaker, name, target.model, options.onEvent, this.logger);
-			return new CallExecutor(name, target.client, target.model, {
-				maxRetries: target.maxRetries ?? options.maxRetries ?? 1,
-				timeoutMs: target.timeoutMs ?? options.timeoutMs ?? 25e3,
-				chunkIdleTimeoutMs: target.chunkIdleTimeoutMs ?? options.chunkIdleTimeoutMs ?? 3e4,
-				baseDelayMs: target.baseDelayMs ?? options.baseDelayMs ?? 500,
-				defaultMaxTokens: target.defaultMaxTokens ?? options.defaultMaxTokens ?? 1e3,
-				defaultTemperature: target.defaultTemperature === void 0 ? primaryDefaultTemperature : target.defaultTemperature,
-				nonRetryableStatus: target.nonRetryableStatus ?? options.nonRetryableStatus ?? [
-					400,
-					401,
-					403,
-					404,
-					422
-				],
-				parseJson: options.parseJson,
-				logger: this.logger,
-				redact: options.redact,
-				onUsage: options.onUsage,
-				onUsageFailure: options.onUsageFailure,
-				onEvent: options.onEvent,
-				breaker,
-				limiter: target.rateLimit ? new RateLimiter(target.rateLimit) : void 0,
-				isFallback
-			});
-		});
-	}
-	/** Logs a failed refundUsage attempt via the configured logger. */
-	logRefundError(logMessage, error) {
-		this.logger.error(logMessage, { message: error instanceof Error ? error.message : "unknown" });
-	}
-	/**
-	* Walks `this.executors` in order, running `attempt` against each until
-	* one succeeds or every target has failed. `run` on a lone target
-	* (no `fallback` configured) throws exactly what it throws today: the
-	* loop's single iteration path is unchanged from pre-fallback behavior.
-	*
-	* For streaming, `attempt` is `executor.runStream`, whose own retries
-	* only cover *opening* the stream (see `CallExecutor.runStream`). A
-	* mid-stream failure surfaces through `finalResult` after this function
-	* has already returned, so it's never seen here and never falls over,
-	* per the streaming limitation: splicing a second model's output into a
-	* response the consumer has already partially rendered would corrupt
-	* it.
-	*/
-	async runFallbackChain(params, requestId, attempt, skipBreakerCheckForFirst = false) {
-		const attempts = [];
-		for (let i = 0; i < this.executors.length; i++) {
-			const executor = this.executors[i];
-			const startedAt = Date.now();
-			let attemptCount = 0;
-			try {
-				if (!(i === 0 && skipBreakerCheckForFirst)) executor.assertBreakerClosed(params.model);
-				const result = await attempt(executor, () => {
-					attemptCount += 1;
-				});
-				return {
-					result,
-					executor,
-					index: i,
-					attemptCount
-				};
-			} catch (error) {
-				const normalized = normalizeError(error, params.signal);
-				attempts.push({
-					index: i - 1,
-					provider: executor.providerName,
-					model: params.model ?? executor.model,
-					error: normalized.toSnapshot()
-				});
-				const isLast = i === this.executors.length - 1;
-				const policyDecision = this.fallbackOn(normalized, { isLastTarget: isLast });
-				const decision = isLast ? "stop" : policyDecision;
-				if (decision === "stop") throw attempts.length > 1 ? new FallbackExhaustedError(attempts) : normalized;
-				const next = this.executors[i + 1];
-				this.reportEvent({
-					kind: "fallback",
-					requestId,
-					from: executor.providerName,
-					to: next.providerName,
-					fromIndex: i - 1,
-					toIndex: i,
-					error: normalized,
-					elapsedMs: Date.now() - startedAt
-				});
-			}
-		}
-		throw new LLMError("No provider targets configured", "invalid_params");
-	}
-	async call(params) {
-		if (params.signal?.aborted) throw new LLMError("LLM request aborted", "aborted");
-		const requestId = params.requestId ?? randomUUID();
-		const soleTarget = this.executors.length === 1;
-		if (soleTarget) this.executors[0].assertBreakerClosed(params.model);
-		if (params.stream) return withReservedUsageForStream(params, async () => {
-			const { result } = await this.runFallbackChain(params, requestId, (executor, onAttempt) => executor.runStream(params, requestId, onAttempt), soleTarget);
-			return result;
-		}, params.signal, (logMessage, error) => this.logRefundError(logMessage, error));
-		return withReservedUsage(params, false, async () => {
-			const { result, executor, index, attemptCount } = await this.runFallbackChain(params, requestId, (target, onAttempt) => target.run(params, requestId, onAttempt), soleTarget);
-			if (params.meta) params.meta.current = {
-				provider: executor.providerName,
-				model: params.model ?? executor.model,
-				fallbackIndex: index - 1,
-				usedFallback: index > 0,
-				attempts: attemptCount
-			};
-			return result;
-		}, params.signal, (logMessage, error) => this.logRefundError(logMessage, error));
-	}
-	/**
-	* Thin delegator kept private on `VernLLM` (rather than only existing on
-	* `CacheOrchestrator`) since it's the one caching primitive exercised
-	* directly by white-box tests, independent of the public `cachedCall()`
-	* surface.
-	*/
-	runCached(params) {
-		return this.cacheOrchestrator.runCached(params);
-	}
-	/**
-	* Removes a cached response by key when the configured cache adapter
-	* supports deletion. Cache invalidation is the caller's responsibility;
-	* only the application knows when cached data is stale.
-	*
-	* @param key The raw cache key (resolved through the adapter's
-	* `resolveKey`, if any, before deletion).
-	*/
-	async deleteCache(key) {
-		await this.cacheOrchestrator.deleteCache(key);
-	}
-	async cachedCall(params) {
-		const { call: callParams,...cacheParams } = params;
-		const restCallParams = callParams;
-		if (restCallParams.reserveUsage || restCallParams.refundUsage) throw new LLMError("`reserveUsage`/`refundUsage` were set inside `call`, where cachedCall ignores them. Move them to the top level of the cachedCall() params, alongside cacheKey/ttl, instead.", "invalid_params");
-		if (restCallParams.stream) {
-			const streamParams = restCallParams;
-			return this.cacheOrchestrator.runCachedStream({
-				...cacheParams,
-				openStream: () => this.call(streamParams)
-			}, Boolean(restCallParams.tools));
-		}
-		return this.runCached({
-			...cacheParams,
-			fn: () => this.call(restCallParams)
-		});
-	}
-	/**
-	* @param target.index Which target to read. Defaults to the primary.
-	* @param target.model Which model bucket to read, if the target isolates by model.
-	* @returns The breaker state, or `undefined` if that target has no breaker.
-	* @throws {RangeError} If `target.index` names no target. Lets a real
-	* target with no breaker (`undefined`) stay distinguishable from a
-	* target that doesn't exist.
-	*/
-	getCircuitState(target) {
-		const executor = this.resolveExecutor(target?.index ?? 0, "getCircuitState");
-		this.warnIfModelUnsupported(executor.isolateByModel, target?.model, "getCircuitState");
-		return executor.getCircuitState(target?.model ?? executor.model);
-	}
-	/**
-	* @param model Which model bucket to read, for targets that isolate by model.
-	* @returns Every target's state, in chain order.
-	*/
-	getCircuitStates(model) {
-		return this.executors.map((executor, index) => ({
-			provider: executor.providerName,
-			index,
-			isFallback: index > 0,
-			isolateByModel: executor.isolateByModel,
-			state: executor.getCircuitState(model ?? executor.model)
-		}));
-	}
-	/**
-	* Manually opens a target's breaker, e.g. to pull a provider out of
-	* rotation ahead of known maintenance instead of waiting for it to fail.
-	*
-	* @param target.index Which target to open. Defaults to the primary.
-	* @param target.model Which model bucket to open, if the target isolates by model.
-	* @throws {RangeError} If `target.index` names no target.
-	*/
-	openCircuit(target) {
-		const executor = this.resolveExecutor(target?.index ?? 0, "openCircuit");
-		this.warnIfModelUnsupported(executor.isolateByModel, target?.model, "openCircuit");
-		executor.openCircuit(target?.model ?? executor.model);
-	}
-	/**
-	* Manually closes a target's breaker, e.g. once a provider is confirmed
-	* healthy again without waiting out the cooldown.
-	*
-	* @param target.index Which target to close. Defaults to the primary.
-	* @param target.model Which model bucket to close, if the target isolates by model.
-	* @throws {RangeError} If `target.index` names no target.
-	*/
-	closeCircuit(target) {
-		const executor = this.resolveExecutor(target?.index ?? 0, "closeCircuit");
-		this.warnIfModelUnsupported(executor.isolateByModel, target?.model, "closeCircuit");
-		executor.closeCircuit(target?.model ?? executor.model);
-	}
-	/** Resolves a target index so every circuit-breaker method agrees on what counts as valid. */
-	resolveExecutor(index, caller) {
-		const executor = this.executors[index];
-		if (!executor) throw new RangeError(`${caller}: no target at index ${index} (chain has ${this.executors.length} target${this.executors.length === 1 ? "" : "s"})`);
-		return executor;
-	}
-	/** Warns when `model` can't do anything on this target, so it's never silently ignored. */
-	warnIfModelUnsupported(isolateByModel, model, caller) {
-		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.`);
-	}
-};
-
-//#endregion
-//#region src/adapters/internal/sse.ts
-/**
-* Parses a Server-Sent-Events byte/text stream into the JSON payload of
-* each `data:` frame, in arrival order. Generic over transport: works with
-* anything that hands back progressively-arriving `Uint8Array` or `string`
-* chunks via async iteration: native `fetch`'s `response.body` (wrapped
-* to be iterable, see `webStreamToAsyncIterable` in `fetch.ts`), axios's
-* Node `Readable` (already async-iterable, no wrapping needed), etc, so
-* this framing layer doesn't care which transport produced the bytes.
-*
-* Follows the SSE spec's frame-delimiting rules closely enough for LLM
-* streaming responses: frames are separated by a blank line, each frame
-* may carry one or more `data:` lines (joined with `\n` per spec when
-* there's more than one), `:`-prefixed lines are comments and ignored, and
-* other SSE fields (`event:`, `id:`, `retry:`) are ignored since VernLLM
-* only needs the payload. A frame whose data is exactly `[DONE]` (the
-* sentinel several providers, notably OpenAI, send to mark stream end)
-* ends iteration without yielding it.
-*
-* Line endings: `\r\n` and bare `\r` (both legal per the SSE spec, alongside `\n`) are normalized
-* to `\n` before frame splitting. A `\r` at the very end of the currently-buffered text is left
-* alone until either more text arrives (in case it's the first half of a split `\r\n` pair) or the
-* stream ends, so a `\r\n` pair split across two transport chunks is never misread as two blank
-* lines.
-*
-* Malformed JSON in a frame throws `LLMError('parse')`, consistent with
-* how malformed JSON is handled elsewhere in VernLLM.
-*/
-async function* parseSseStream(source) {
-	const decoder = new TextDecoder("utf-8", { fatal: true });
-	let buffer = "";
-	for await (const chunk of source) {
-		let text;
-		try {
-			text = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
-		} catch (cause) {
-			throw new LLMError("Invalid UTF-8 in SSE stream", "parse", { cause });
-		}
-		buffer = (buffer + text).replace(/\r\n/g, "\n").replace(/\r(?!$)/g, "\n");
-		let boundary$1 = buffer.indexOf("\n\n");
-		while (boundary$1 !== -1) {
-			const frame = buffer.slice(0, boundary$1);
-			buffer = buffer.slice(boundary$1 + 2);
-			const event = parseSseFrame(frame);
-			if (event === DONE) return;
-			if (event !== NO_DATA) yield event;
-			boundary$1 = buffer.indexOf("\n\n");
-		}
-	}
-	try {
-		buffer += decoder.decode();
-	} catch (cause) {
-		throw new LLMError("Invalid UTF-8 in SSE stream", "parse", { cause });
-	}
-	buffer = buffer.replace(/\r$/, "\n");
-	let boundary = buffer.indexOf("\n\n");
-	while (boundary !== -1) {
-		const frame = buffer.slice(0, boundary);
-		buffer = buffer.slice(boundary + 2);
-		const event = parseSseFrame(frame);
-		if (event === DONE) return;
-		if (event !== NO_DATA) yield event;
-		boundary = buffer.indexOf("\n\n");
-	}
-	const trailing = buffer.trim();
-	if (trailing) {
-		const event = parseSseFrame(trailing);
-		if (event !== DONE && event !== NO_DATA) yield event;
-	}
-}
-const DONE = Symbol("sse-stream-done");
-const NO_DATA = Symbol("sse-frame-no-data");
-/**
-* Sentinel yielded by `parseSseStream` for a comment-only frame (no
-* `data:` payload), the mechanism providers use for SSE keep-alive
-* pings. Exported so a consumer (e.g. `fromFetch`) can react to "still
-* alive" separately from a genuinely empty frame (`NO_DATA`, kept internal).
-*/
-const SSE_PING = Symbol("sse-frame-ping");
-/** Extracts and JSON-parses the `data:` payload of one SSE frame (the text between two blank lines). */
-function parseSseFrame(frame) {
-	const dataLines = [];
-	let sawComment = false;
-	for (const line of frame.split("\n")) {
-		if (line.startsWith(":")) {
-			sawComment = true;
-			continue;
-		}
-		if (!line.startsWith("data:")) continue;
-		dataLines.push(line.startsWith("data: ") ? line.slice(6) : line.slice(5));
-	}
-	if (!dataLines.length) return sawComment ? SSE_PING : NO_DATA;
-	const data = dataLines.join("\n");
-	if (data === "[DONE]") return DONE;
-	try {
-		return JSON.parse(data);
-	} catch (cause) {
-		throw new LLMError(`Invalid JSON in SSE frame: ${data.slice(0, 200)}`, "parse", {
-			cause,
-			code: "stream_frame_invalid"
-		});
-	}
-}
-
-//#endregion
-//#region src/adapters/internal/imageFormat.ts
-/**
-* MIME types accepted for `ImageBlock.mimeType` across all adapters. This is
-* the intersection of what Anthropic, Gemini, OpenAI-compatible, and Bedrock
-* Converse all natively support, so a `ContentBlock[]` that validates for
-* one provider validates for all of them.
-*/
-const SUPPORTED_IMAGE_MIME_TYPES = [
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp"
-];
-/**
-* Validates an `ImageBlock.mimeType` against the shared supported set.
-* Throws a non-retryable `LLMError('invalid_params')`, since an unsupported
-* mimeType is a bug in the caller's own input, deterministic before any
-* request is built, the same class of failure as every other check in
-* `RequestBuilder`.
-*/
-function assertSupportedImageMimeType(mimeType) {
-	if (SUPPORTED_IMAGE_MIME_TYPES.includes(mimeType)) return mimeType;
-	throw new LLMError(`Unsupported image mimeType "${mimeType}": expected one of ${SUPPORTED_IMAGE_MIME_TYPES.join(", ")}`, "invalid_params");
-}
-
-//#endregion
-//#region src/adapters/internal/nativeStructuredOutput.ts
-/** Resolves whether `model` is covered by a caller-supplied allow-list/predicate. */
-function supportsNativeStructuredOutput(model, override) {
-	if (!override) return false;
-	return Array.isArray(override) ? override.includes(model) : override(model);
-}
-
-//#endregion
-//#region src/adapters/anthropic.ts
-/**
-* Translates a VernLLM `ContentBlock[]` (our provider-agnostic multimodal
-* shape) into Anthropic's native content-block array: text blocks pass
-* through as-is, image blocks become `{ type: 'image', source: { type:
-* 'base64', media_type, data } }`.
-*/
-function toAnthropicContent(blocks) {
-	return blocks.map((block) => block.type === "image" ? {
-		type: "image",
-		source: {
-			type: "base64",
-			media_type: assertSupportedImageMimeType(block.mimeType),
-			data: block.data
-		}
-	} : {
-		type: "text",
-		text: block.text
-	});
-}
-/**
-* Asserts a caller-supplied JSON Schema is an object schema before it's
-* used as Anthropic's `Tool.input_schema`, which (like every other
-* provider's function-calling API) requires `type: 'object'`. VernLLM's own
-* public `tools`/`jsonSchema` APIs accept freeform `Record<string,
-* unknown>` JSON Schema, so nothing upstream guarantees this at compile
-* time; this is the runtime check that stands in for that, so a schema
-* missing (or mistyping) `type: 'object'` fails loudly and immediately
-* instead of being silently forwarded to Anthropic malformed.
-*/
-function assertObjectSchema(schema, toolName) {
-	if (schema.type !== "object") throw new LLMError(`Tool "${toolName}"'s schema must have "type": "object" (Anthropic requires object-shaped tool parameters).`, "validation");
-	return schema;
-}
-/**
-* Translates VernLLM's OpenAI-shaped wire `tool_choice` into Anthropic's
-* `{ type: 'auto' | 'any' | 'none' | 'tool', name? }` shape. `'required'`
-* maps to `'any'` (Anthropic's "must call some tool" equivalent).
-*/
-function toAnthropicToolChoice(toolChoice) {
-	if (!toolChoice || toolChoice === "auto") return { type: "auto" };
-	if (toolChoice === "none") return { type: "none" };
-	if (toolChoice === "required") return { type: "any" };
-	return {
-		type: "tool",
-		name: toolChoice.function.name
-	};
-}
-/**
-* Maps VernLLM's OpenAI-shaped wire `tools`/`tool_choice` into Anthropic's
-* `tools`/`tool_choice` shape. Shared by the two call sites that build real
-* (non-schema-forced) tool definitions: the plain tools-only branch, and
-* the native-structured-output branch, which sends real tools alongside
-* `output_config` rather than instead of it.
-*/
-function buildAnthropicTools(tools, toolChoiceParam) {
-	return {
-		tools: tools.map((t) => ({
-			name: t.function.name,
-			description: t.function.description,
-			input_schema: assertObjectSchema(t.function.parameters, t.function.name)
-		})),
-		toolChoice: toAnthropicToolChoice(toolChoiceParam)
-	};
-}
-/**
-* Builds the Anthropic-shaped request body from VernLLM's wire params,
-* shared between `create` and `createStream` so both go through identical
-* translation (system prompt, message shaping, and the jsonSchema →
-* forced-single-tool mapping all happen exactly once, not once per entry
-* point).
-*
-* Returns `toolName` alongside the body: when set, the model was forced to
-* call a single synthetic tool standing in for `jsonSchema` output (the
-* legacy path, for models without native structured-output support), and
-* both `create` and `createStream` need to know this so they can unwrap
-* that tool call back into plain text content instead of treating it like
-* a real tool call. On the native path (model supports `output_config`),
-* `toolName` is `undefined`: the schema-conforming JSON already arrives as
-* ordinary text content, nothing to unwrap, and any real tool calls in
-* `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) {
-	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;
-	const schemaName = jsonSchema?.name.trim();
-	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");
-	let toolName;
-	let jsonInstruction;
-	let outputFormat;
-	let tools;
-	let toolChoice;
-	if (jsonSchema && isNative) {
-		outputFormat = {
-			type: "json_schema",
-			schema: jsonSchema.schema
-		};
-		if (params.tools?.length) ({tools, toolChoice} = buildAnthropicTools(params.tools, params.tool_choice));
-	} else if (jsonSchema && schemaName) {
-		const { schema, description, strict } = jsonSchema;
-		toolName = schemaName;
-		tools = [{
-			name: toolName,
-			description,
-			input_schema: assertObjectSchema(schema, toolName),
-			strict
-		}];
-		toolChoice = {
-			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");
-	const body = {
-		model: params.model,
-		max_tokens: params.max_tokens,
-		...params.temperature !== void 0 ? { temperature: params.temperature } : {},
-		system: system || void 0,
-		messages: mergeConsecutiveToolResults$1(conversationMessages.map((m) => toAnthropicMessage(m))),
-		...tools ? {
-			tools,
-			tool_choice: toolChoice
-		} : {},
-		...outputFormat ? { output_config: { format: outputFormat } } : {}
-	};
-	return {
-		body,
-		toolName
-	};
-}
-/**
-* Wraps an Anthropic SDK client so it satisfies the same `LLMClient`
-* interface VernLLM uses for OpenAI/Groq.
-*
-* `response_format: json_schema`, on a model covered by
-* `options.nativeStructuredOutputModels`, is sent as `output_config.format`,
-* its own request field, independent of `tools`/`tool_choice`, so it can be
-* combined with real, caller-supplied `tools` in the same request. Only
-* `type` and `schema` are sent on this path, the real Anthropic API's
-* `output_config.format` has no `name`/`description`/`strict` fields.
-*
-* On any other model (the default, since `nativeStructuredOutputModels` is
-* opt-in), `response_format: json_schema` is mapped to Anthropic's forced
-* tool-use instead: a single tool is defined with `input_schema` set to
-* the caller's schema, `description` forwarded when provided, and `strict`
-* forwarded when set, and `tool_choice` forces the model to call it. This
-* legacy path cannot be combined with real `tools` (both would need the
-* same `tools`/`tool_choice` field), and a call that tries throws
-* `LLMError('validation')` before reaching the API. Provider-constrained
-* 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.
-*/
-function fromAnthropic(anthropicClient, options) {
-	const nativeStructuredOutputModels = options?.nativeStructuredOutputModels;
-	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)
-				}
-			};
-		},
-		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
-				};
-			} 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 === "message_delta") {
-				const outputTokens = event.usage?.output_tokens ?? 0;
-				yield {
-					type: "usage",
-					usage: {
-						prompt_tokens: inputTokens,
-						completion_tokens: outputTokens,
-						total_tokens: inputTokens + outputTokens
-					}
-				};
-			} 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
-* mapping above (one `{role:'user', content:[tool_result]}` per VernLLM
-* wire tool message) needs merging back together when an assistant turn
-* requested more than one tool: multiple consecutive user turns would
-* violate that alternation, and Anthropic's API rejects it outright. This
-* merges any run of tool-result-only user messages into one, with all
-* their tool_result blocks combined, the shape Anthropic expects for "here
-* are the results of everything you just asked for."
-*/
-function mergeConsecutiveToolResults$1(messages) {
-	const isToolResultOnly = (m) => m.role === "user" && Array.isArray(m.content) && m.content.length > 0 && m.content.every((b) => b.type === "tool_result");
-	const merged = [];
-	for (const m of messages) {
-		const prev = merged.at(-1);
-		if (isToolResultOnly(m) && prev && isToolResultOnly(prev)) prev.content.push(...m.content);
-		else merged.push(m);
-	}
-	return merged;
-}
-/**
-* Translates one VernLLM wire message (OpenAI-shaped: plain user/assistant
-* turns, an assistant turn with `tool_calls`, or a `tool` turn) into
-* Anthropic's `{ role: 'user' | 'assistant', content }` shape.
-*/
-function toAnthropicMessage(m) {
-	if (m.role === "tool") return {
-		role: "user",
-		content: [{
-			type: "tool_result",
-			tool_use_id: m.tool_call_id,
-			content: m.content,
-			...m.is_error ? { is_error: true } : {}
-		}]
-	};
-	if (m.role === "assistant" && m.tool_calls?.length) {
-		const blocks = [];
-		if (m.content) blocks.push({
-			type: "text",
-			text: m.content
-		});
-		for (const tc of m.tool_calls) {
-			let input;
-			try {
-				input = tc.function.arguments.trim() ? JSON.parse(tc.function.arguments) : {};
-			} catch (cause) {
-				throw new LLMError(`Assistant tool call "${tc.function.name}" (${tc.id}) has arguments that are not valid JSON.`, "validation", { cause });
-			}
-			if (input === null || Array.isArray(input) || typeof input !== "object") throw new LLMError(`Assistant tool call "${tc.function.name}" (${tc.id}) arguments must be a JSON object.`, "validation");
-			blocks.push({
-				type: "tool_use",
-				id: tc.id,
-				name: tc.function.name,
-				input
-			});
-		}
-		return {
-			role: "assistant",
-			content: blocks
-		};
-	}
-	return {
-		role: m.role,
-		content: Array.isArray(m.content) ? toAnthropicContent(m.content) : m.content ?? ""
-	};
-}
-
-//#endregion
-//#region src/adapters/gemini.ts
-/**
-* Translates a VernLLM `ContentBlock[]` into Gemini's native `parts` array:
-* text blocks become `{ text }`, image blocks become inline data parts
-* (`{ inlineData: { mimeType, data } }`), Gemini's shape for embedding raw
-* base64 image bytes directly in the request.
-*/
-function toGeminiParts(blocks) {
-	return blocks.map((block) => block.type === "image" ? { inlineData: {
-		mimeType: assertSupportedImageMimeType(block.mimeType),
-		data: block.data
-	} } : { text: block.text });
-}
-/** Maps VernLLM's OpenAI-shaped wire `tool_choice` onto Gemini's `functionCallingConfig`. */
-function toGeminiToolConfig(toolChoice) {
-	if (!toolChoice || toolChoice === "auto") return { functionCallingConfig: { mode: "AUTO" } };
-	if (toolChoice === "none") return { functionCallingConfig: { mode: "NONE" } };
-	if (toolChoice === "required") return { functionCallingConfig: { mode: "ANY" } };
-	return { functionCallingConfig: {
-		mode: "ANY",
-		allowedFunctionNames: [toolChoice.function.name]
-	} };
-}
-/**
-* Translates one VernLLM wire message into a Gemini `contents` entry.
-* Gemini has no separate 'tool' role: a prior assistant tool request
-* becomes a `'model'` turn with `functionCall` parts, and its result
-* becomes a `'user'` turn with `functionResponse` parts.
-*/
-function toGeminiContent(m) {
-	if (m.role === "tool") return {
-		role: "user",
-		parts: [{ functionResponse: {
-			name: m.tool_call_id,
-			response: parseToolResult(m.content)
-		} }]
-	};
-	if (m.role === "assistant" && m.tool_calls?.length) {
-		const parts = [];
-		if (typeof m.content === "string" && m.content) parts.push({ text: m.content });
-		parts.push(...m.tool_calls.map((tc) => ({ functionCall: {
-			name: tc.function.name,
-			args: parseToolArguments(tc.function.arguments, tc.function.name)
-		} })));
-		return {
-			role: "model",
-			parts
-		};
-	}
-	return {
-		role: m.role === "assistant" ? "model" : "user",
-		parts: Array.isArray(m.content) ? toGeminiParts(m.content) : [{ text: m.content ?? "" }]
-	};
-}
-function parseToolArguments(text, toolName) {
-	let parsed;
-	try {
-		parsed = text.trim() ? JSON.parse(text) : {};
-	} catch (cause) {
-		throw new LLMError(`Tool call "${toolName}" arguments are not valid JSON.`, "parse", {
-			cause,
-			code: "tool_arguments_parse_failed"
-		});
-	}
-	if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new LLMError(`Tool call "${toolName}" arguments must be a JSON object.`, "validation");
-	return parsed;
-}
-function parseToolResult(text) {
-	try {
-		return text.trim() ? JSON.parse(text) : "";
-	} catch {
-		return text;
-	}
-}
-/**
-* Gemini expects the results of everything the model asked for in one turn
-* to arrive together as multiple `functionResponse` parts on a single
-* `'user'` entry, not as separate consecutive `'user'` entries. The
-* per-wire-message mapping above produces one `'user'` entry per VernLLM
-* wire tool message, so when an assistant turn requested more than one
-* tool, this merges the resulting run of functionResponse-only `'user'`
-* entries back into one.
-*/
-function mergeConsecutiveFunctionResponses(contents) {
-	const isFunctionResponseOnly = (c) => c.role === "user" && c.parts.length > 0 && c.parts.every((p) => "functionResponse" in p);
-	const merged = [];
-	for (const c of contents) {
-		const prev = merged.at(-1);
-		if (isFunctionResponseOnly(c) && prev && isFunctionResponseOnly(prev)) prev.parts.push(...c.parts);
-		else merged.push(c);
-	}
-	return merged;
-}
-/**
-* Builds the Gemini-shaped request from VernLLM's wire params, shared
-* between `create` and `createStream` so both go through identical
-* translation (contents shaping, `responseSchema`/`responseMimeType`
-* mapping, and tool/toolConfig translation all happen exactly once).
-* `abortSignal` is folded into `config` by the caller (`create`/
-* `createStream`), once the request options are available.
-*/
-function buildGeminiRequest(params) {
-	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);
-	const config = {
-		...params.temperature !== void 0 ? { temperature: params.temperature } : {},
-		maxOutputTokens: params.max_tokens,
-		...systemMessage ? { systemInstruction: { parts: [{ text: systemMessage.content }] } } : {}
-	};
-	if (wantsJson) config.responseMimeType = "application/json";
-	if (params.response_format?.type === "json_schema") {
-		const { schema, description } = params.response_format.json_schema;
-		config.responseSchema = {
-			...schema,
-			...description ? { description } : {}
-		};
-	}
-	if (params.tools?.length) {
-		config.tools = [{ functionDeclarations: params.tools.map((t) => ({
-			name: t.function.name,
-			description: t.function.description,
-			parameters: t.function.parameters
-		})) }];
-		config.toolConfig = toGeminiToolConfig(params.tool_choice);
-	}
-	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) {
-	return { chat: { completions: {
-		async create(params, options) {
-			const request = buildGeminiRequest(params);
-			request.config = {
-				...request.config,
-				abortSignal: options.signal
-			};
-			const response = await geminiClient.generateContent(request);
-			const parts = response.candidates?.[0]?.content?.parts ?? [];
-			const text = parts.map((p) => p.text ?? "").join("");
-			const functionCalls = parts.filter((p) => p.functionCall);
-			let wireToolCalls;
-			if (functionCalls.length) wireToolCalls = functionCalls.map((p) => ({
-				id: p.functionCall.name,
-				type: "function",
-				function: {
-					name: p.functionCall.name,
-					arguments: JSON.stringify(p.functionCall.args ?? {})
-				}
-			}));
-			return {
-				choices: [{ message: {
-					content: text,
-					...wireToolCalls ? { tool_calls: wireToolCalls } : {}
-				} }],
-				usage: {
-					prompt_tokens: response.usageMetadata?.promptTokenCount,
-					completion_tokens: response.usageMetadata?.candidatesTokenCount,
-					total_tokens: response.usageMetadata?.totalTokenCount
-				}
-			};
-		},
-		async *createStream(params, options) {
-			if (!geminiClient.generateContentStream) throw new LLMError("stream: true requires a Gemini client with generateContentStream", "invalid_params", {
-				code: "unsupported_capability",
-				issues: { capability: "generateContentStream" }
-			});
-			const request = buildGeminiRequest(params);
-			request.config = {
-				...request.config,
-				abortSignal: options.signal
-			};
-			const stream = await geminiClient.generateContentStream(request);
-			let toolCallIndex = 0;
-			let lastUsage;
-			for await (const chunk of stream) {
-				const parts = chunk.candidates?.[0]?.content?.parts ?? [];
-				for (const part of parts) {
-					if (part.text) yield {
-						type: "text-delta",
-						delta: part.text
-					};
-					if (part.functionCall) {
-						yield {
-							type: "tool_call_delta",
-							index: toolCallIndex,
-							id: part.functionCall.name,
-							name: part.functionCall.name,
-							argumentsDelta: JSON.stringify(part.functionCall.args ?? {}),
-							complete: true
-						};
-						toolCallIndex++;
-					}
-				}
-				if (chunk.usageMetadata) lastUsage = chunk.usageMetadata;
-			}
-			if (lastUsage) yield {
-				type: "usage",
-				usage: {
-					prompt_tokens: lastUsage.promptTokenCount,
-					completion_tokens: lastUsage.candidatesTokenCount,
-					total_tokens: lastUsage.totalTokenCount
-				}
-			};
-		}
-	} } };
-}
-
-//#endregion
-//#region src/adapters/bedrock.ts
-/** Maps a `ContentBlock` image MIME type, already validated, to Converse's `format` enum. */
-function toBedrockImageFormat(mimeType) {
-	switch (assertSupportedImageMimeType(mimeType)) {
-		case "image/png": return "png";
-		case "image/jpeg": return "jpeg";
-		case "image/gif": return "gif";
-		case "image/webp": return "webp";
-	}
-}
-/**
-* Decodes base64 image data into the raw `Uint8Array` bytes Converse's
-* `image.source.bytes` expects (unlike Anthropic/Gemini/OpenAI, which all
-* take base64 strings directly). Uses `Buffer`, since this adapter, like
-* the rest of the package, targets Node.
-*/
-function decodeBase64(data) {
-	return new Uint8Array(Buffer.from(data, "base64"));
-}
-/**
-* Translates a VernLLM `ContentBlock[]` into Converse's native content-block
-* array: text blocks pass through as `{ text }`, image blocks become
-* `{ image: { format, source: { bytes } } }` with the base64 payload decoded
-* to raw bytes, since Converse doesn't accept base64 strings directly.
-*/
-function toBedrockContent(blocks) {
-	return blocks.map((block) => block.type === "image" ? { image: {
-		format: toBedrockImageFormat(block.mimeType),
-		source: { bytes: decodeBase64(block.data) }
-	} } : { text: block.text });
-}
-/**
-* Maps VernLLM's OpenAI-shaped wire `tools`/`tool_choice` into Converse's
-* `toolConfig` shape. Shared by the two call sites that build real
-* (non-schema-forced) tool definitions: the plain tools-only branch, and
-* the native-structured-output branch, which sends real tools alongside
-* `outputConfig` rather than instead of it.
-*/
-function buildBedrockToolConfig(tools, toolChoiceParam) {
-	return {
-		tools: tools.map((t) => ({ toolSpec: {
-			name: t.function.name,
-			description: t.function.description,
-			inputSchema: { json: t.function.parameters }
-		} })),
-		toolChoice: toBedrockToolChoice(toolChoiceParam)
-	};
-}
-/**
-* Builds the Converse-shaped request from VernLLM's wire params, shared
-* between `create` and `createStream` so both go through identical
-* translation (system prompt, message shaping, the jsonSchema →
-* forced-single-tool mapping, and the `toolUseSupportedModels` preflight
-* check all happen exactly once).
-*
-* Returns `toolName` alongside the request: when set, the model was forced
-* to call a single synthetic tool standing in for `jsonSchema` output (the
-* legacy path, for models not covered by `nativeStructuredOutputModels`),
-* and both `create` and `createStream` need to know this so they can
-* unwrap that tool call back into plain text content instead of treating
-* it like a real tool call. On the native path (model covered by
-* `nativeStructuredOutputModels`), `toolName` is `undefined`: the
-* schema-conforming JSON already arrives as ordinary text content, nothing
-* to unwrap, and any real tool calls in `params.tools` are left for the
-* normal, non-forced tool-call handling both `create` and `createStream`
-* already do when `toolName` is unset.
-*/
-function buildBedrockRequest(params, toolUseSupportedModels, nativeStructuredOutputModels) {
-	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;
-	const schemaName = jsonSchema?.name.trim();
-	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");
-	let toolName;
-	let jsonInstruction;
-	let toolConfig;
-	let outputConfig;
-	if (jsonSchema && isNative) {
-		const { schema, description } = jsonSchema;
-		outputConfig = { textFormat: {
-			type: "json_schema",
-			structure: { jsonSchema: {
-				schema: JSON.stringify(schema),
-				name: schemaName,
-				description
-			} }
-		} };
-	} else if (jsonSchema && schemaName) {
-		const { schema, description, strict } = jsonSchema;
-		toolName = schemaName;
-		toolConfig = {
-			tools: [{ toolSpec: {
-				name: toolName,
-				description,
-				inputSchema: { json: schema },
-				strict
-			} }],
-			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);
-		if (!isSupported) throw new LLMError(`Bedrock model "${params.model}" is not listed in toolUseSupportedModels, but this call requires Converse tool use (either jsonSchema emulated as a forced tool call, or real \`tools\` sent alongside native structured output).`, "invalid_params", {
-			code: "unsupported_capability",
-			issues: { capability: "toolUseSupportedModels" }
-		});
-	}
-	const systemParts = [systemMessage?.content, jsonInstruction].filter((s) => Boolean(s));
-	const request = {
-		modelId: params.model,
-		messages: mergeConsecutiveToolResults(conversationMessages.map((m) => toBedrockMessage(m))),
-		system: systemParts.length ? systemParts.map((text) => ({ text })) : void 0,
-		inferenceConfig: {
-			...params.temperature !== void 0 ? { temperature: params.temperature } : {},
-			maxTokens: params.max_tokens
-		},
-		...toolConfig ? { toolConfig } : {},
-		...outputConfig ? { outputConfig } : {}
-	};
-	return {
-		request,
-		toolName
-	};
-}
-/**
-* 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.),
-* so unlike raw per-model Bedrock invocation, this one adapter works
-* regardless of which underlying model `modelId` points at, as long as
-* that model supports Converse (most current-generation ones do)
-*
-* `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
-* `toolConfig`, so it can be combined with real, caller-supplied `tools`
-* in the same request. Matches the real Converse API's shape exactly: the
-* schema is nested under `structure.jsonSchema` and JSON-encoded as a
-* string, not the parsed object `toolConfig`'s tool schemas use, and there
-* is no `strict` field on this path.
-*
-* On any other model (the default), `response_format: json_schema` is
-* mapped to Converse's `toolConfig` instead: a single tool is defined from
-* the schema, description, and strictness settings, and `toolChoice`
-* forces the model to call it. This legacy path cannot be combined with
-* real `tools` (both would need the same `toolConfig`), and a call that
-* tries throws `LLMError('validation')` before reaching the API.
-* Provider-constrained schema matching applies only when `strict: true` is
-* forwarded and supported. Native tool support varies by model family;
-* pass `toolUseSupportedModels` to preflight-check it (see
-* `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.
-*
-* `tools` alone maps to Converse's native `toolConfig`/`toolUse`/
-* `toolResult`; `tool_choice` maps to `toolConfig.toolChoice`.
-*
-* `createStream` calls `converseStream` (optional on `BedrockConverseClient`
-*, required only if the caller sets `stream: true`) and translates its
-* `contentBlockStart`/`contentBlockDelta`/`metadata` events into
-* `WireStreamChunk`s. Content blocks are tracked by `contentBlockIndex`,
-* same as `fromAnthropic`'s block-index tracking (Converse's streaming
-* shape is structurally close to Anthropic's own, both being tool-use-aware
-* content-block streams), including the same `json-tool` unwrapping: a
-* `jsonSchema`-forced tool's `toolUse.input` deltas are re-emitted as
-* `text-delta`, not `tool_call_delta`, so the accumulated result lands in
-* `finalizeResponse`'s `content` path exactly like the non-streaming
-* `create` branch above unwraps it.
-*/
-function fromBedrock(bedrockClient, options) {
-	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
-				}
-			};
-		},
-		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
-				};
-				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) {
-	if (!toolChoice || toolChoice === "auto") return { auto: {} };
-	if (toolChoice === "required") return { any: {} };
-	if (toolChoice === "none") throw new LLMError("'none' is not supported by fromBedrock: Bedrock Converse has no `tool_choice` equivalent to forbidding tool use while tools are still offered. Omit `tools` entirely for this call instead.", "invalid_params", {
-		code: "unsupported_capability",
-		issues: { capability: "toolChoice: 'none'" }
-	});
-	return { tool: { name: toolChoice.function.name } };
-}
-/**
-* Translates one VernLLM wire message into Converse's
-* `{ role: 'user' | 'assistant', content }` shape.
-*/
-function toBedrockMessage(m) {
-	if (m.role === "tool") return {
-		role: "user",
-		content: [{ toolResult: {
-			toolUseId: m.tool_call_id,
-			content: [{ text: m.content }],
-			status: m.is_error ? "error" : "success"
-		} }]
-	};
-	if (m.role === "assistant" && m.tool_calls?.length) {
-		const blocks = [];
-		if (m.content) blocks.push({ text: m.content });
-		for (const tc of m.tool_calls) {
-			let input;
-			if (!tc.function.arguments.trim()) input = {};
-			else try {
-				input = JSON.parse(tc.function.arguments);
-			} catch (cause) {
-				throw new LLMError(`Assistant tool call "${tc.function.name}" (${tc.id}) has arguments that are not valid JSON.`, "validation", { cause });
-			}
-			blocks.push({ toolUse: {
-				toolUseId: tc.id,
-				name: tc.function.name,
-				input
-			} });
-		}
-		return {
-			role: "assistant",
-			content: blocks
-		};
-	}
-	return {
-		role: m.role,
-		content: Array.isArray(m.content) ? toBedrockContent(m.content) : [{ text: m.content ?? "" }]
-	};
-}
-/**
-* Converse expects the results of everything the model asked for in one
-* turn to arrive together as multiple `toolResult` content blocks on a
-* single `'user'` message, not as separate consecutive `'user'` messages.
-* The per-wire-message mapping above produces one `'user'` message per
-* VernLLM wire tool message, so when an assistant turn requested more than
-* one tool, this merges the resulting run of toolResult-only `'user'`
-* messages back into one.
-*/
-function mergeConsecutiveToolResults(messages) {
-	const isToolResultOnly = (m) => m.role === "user" && m.content.length > 0 && m.content.every((b) => "toolResult" in b);
-	const merged = [];
-	for (const m of messages) {
-		const prev = merged.at(-1);
-		if (isToolResultOnly(m) && prev && isToolResultOnly(prev)) prev.content.push(...m.content);
-		else merged.push(m);
-	}
-	return merged;
-}
-
-//#endregion
-//#region src/adapters/fetch.ts
-/**
-* Wraps a WHATWG `ReadableStream` (what `response.body` is) so it can be
-* consumed with `for await`. Implemented via `getReader()` rather than
-* relying on `ReadableStream` having a native `Symbol.asyncIterator`,
-* that support varies across runtimes/versions, and this works everywhere
-* a `ReadableStream` does.
-*/
-async function* webStreamToAsyncIterable(stream) {
-	const reader = stream.getReader();
-	try {
-		for (;;) {
-			const { done, value } = await reader.read();
-			if (done) return;
-			if (value) yield value;
-		}
-	} finally {
-		try {
-			await reader.cancel();
-		} catch {}
-		reader.releaseLock();
-	}
-}
-/** Default `requestStream`: native `fetch`, with the same error/`.status` contract non-streaming errors get. */
-async function defaultRequestStream(url, init) {
-	const res = await fetch(url, init);
-	if (!res.ok) {
-		const body = await res.text().catch(() => "");
-		const err = new Error(`Fetch adapter stream request failed (${res.status}): ${body.slice(0, 500)}`);
-		err.status = res.status;
-		err.headers = res.headers;
-		throw err;
-	}
-	if (!res.body) throw new Error("Fetch adapter stream request received a response with no body.");
-	return webStreamToAsyncIterable(res.body);
-}
-/** Builds the shared `{ method, headers, body? }` request-init for both `create` and `createStream`. */
-async function buildRequestInit(config, params, requestBody) {
-	const url = typeof config.url === "function" ? config.url(params) : config.url;
-	const headers = typeof config.headers === "function" ? await config.headers() : config.headers;
-	const method = config.method ?? "POST";
-	const supportsBody = !["GET", "HEAD"].includes(method.toUpperCase());
-	return {
-		url,
-		method,
-		headers: supportsBody ? {
-			"Content-Type": "application/json",
-			...headers
-		} : { ...headers },
-		...supportsBody ? { body: JSON.stringify(requestBody) } : {}
-	};
-}
-/**
-* A fetch-based escape hatch for providers with no SDK, or where pulling one
-* in isnt worth it. You supply the URL, headers, and two small mapping
-* functions; this handles the HTTP call and slots the result into the same
-* `LLMClient` shape every other adapter produces, so retries, timeouts,
-* the circuit breaker, and JSON/schema handling all still work unmodified
-*
-* Non-2xx responses throw an error with `.status` set to the HTTP status
-* code, so VernLLMs `nonRetryableStatus` handling (e.g. failing fast on
-* 401/403) applies here too
-*
-* Tool calling works the same way as every other adapter: `mapRequest`
-* receives the full `ChatRequest`, including `tools`/`toolChoice`, so it can
-* translate them into whatever shape the provider's wire format expects
-* (typically an OpenAI-`function`-wrapped `tools` array plus a `tool_choice`
-* field). On the way back, `mapResponse` may return a `toolCalls` array
-* (id/name/JSON-encoded-arguments-string per call) alongside or instead of
-* `content`; VernLLM parses and (if `argumentsSchema` was set) validates
-* those arguments the same way it does for every other adapter. For
-* `stream: true`, tool-call deltas go through the existing
-* `mapStreamEvent` seam via `WireStreamChunk`'s `tool_call_delta` variant,
-* no separate config is needed for streaming vs non-streaming tool calls.
-*
-
-* `createStream` requires `mapStreamEvent` (there's no non-streaming
-* response to fall back on, unlike the other three optional streaming
-* seams). It opens the request via `requestStream` (defaults to native
-* `fetch`), splits the raw bytes into individual events via
-* `parseStreamFrames` (defaults to SSE framing, see `parseSseStream`),
-* and translates each event into `WireStreamChunk`(s) via
-* `mapStreamEvent`. Both seams are overridable per-config for providers
-* that don't fit the SSE-over-fetch default. If a custom `request`
-* transport is configured, `requestStream` must be configured too,
-* `requestStream` never silently falls back to `request` (see
-* `createStream`'s own comment for why), so a `stream: true` call with
-* `request` set but no `requestStream` throws a clear
-* `LLMError('validation')` instead of quietly using unrelated native
-* `fetch`.
-*/
-function fromFetch(config) {
-	return { chat: { completions: {
-		async create(params, options) {
-			const { url, method, headers, body } = await buildRequestInit(config, params, config.mapRequest(params));
-			const request = config.request ?? fetch;
-			const res = await request(url, {
-				method,
-				headers,
-				body,
-				signal: options.signal
-			});
-			if (!res.ok) {
-				const responseBody = await res.text().catch(() => "");
-				const err = new Error(`Fetch adapter request failed (${res.status}): ${responseBody.slice(0, 500)}`);
-				err.status = res.status;
-				err.headers = res.headers;
-				throw err;
-			}
-			const json = await res.json();
-			const { content, usage, toolCalls } = config.mapResponse(json);
-			const wireToolCalls = toolCalls?.length ? toolCalls.map((tc) => ({
-				id: tc.id,
-				type: "function",
-				function: {
-					name: tc.name,
-					arguments: tc.arguments
-				}
-			})) : void 0;
-			return {
-				choices: [{ message: {
-					content,
-					...wireToolCalls ? { tool_calls: wireToolCalls } : {}
-				} }],
-				usage: usage ? {
-					prompt_tokens: usage.promptTokens,
-					completion_tokens: usage.completionTokens,
-					total_tokens: usage.totalTokens
-				} : void 0
-			};
-		},
-		async *createStream(params, options) {
-			if (!config.mapStreamEvent) throw new LLMError("stream: true requires mapStreamEvent to be configured on fromFetch", "invalid_params", {
-				code: "unsupported_capability",
-				issues: { capability: "mapStreamEvent" }
-			});
-			if (config.request && !config.requestStream) throw new LLMError("`stream: true` requires `requestStream` to be configured on fromFetch when a custom `request` transport is set. `requestStream` does not fall back to `request` (it needs an async-iterable byte stream, which `RequestLike`'s buffered `ResponseLike` has no way to provide), without it, `stream: true` would silently use plain native `fetch` instead of your configured transport. Add a `requestStream` that opens the same connection your `request` does, or omit `request` if native `fetch` is fine for both.", "invalid_params", {
-				code: "unsupported_capability",
-				issues: { capability: "requestStream" }
-			});
-			const { url, method, headers, body } = await buildRequestInit(config, params, config.mapRequest(params));
-			const requestStream = config.requestStream ?? defaultRequestStream;
-			const parseFrames = config.parseStreamFrames ?? parseSseStream;
-			const byteStream = await requestStream(url, {
-				method,
-				headers,
-				body,
-				signal: options.signal
-			});
-			for await (const event of parseFrames(byteStream)) {
-				if (event === SSE_PING) {
-					yield { type: "ping" };
-					continue;
-				}
-				const wireChunks = config.mapStreamEvent(event);
-				if (!wireChunks) continue;
-				if (Array.isArray(wireChunks)) yield* wireChunks;
-				else yield wireChunks;
-			}
-		}
-	} } };
-}
-
-//#endregion
-//#region src/adapters/openaiCompatible.ts
-/**
-* 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
-* inlined as a `data:` URL, since our `ContentBlock` shape (`{ type:
-* 'image', data, mimeType }`) is provider-agnostic and doesn't itself match
-* OpenAI's wire format.
-*/
-function toOpenAIContent(blocks) {
-	return blocks.map((block) => block.type === "image" ? {
-		type: "image_url",
-		image_url: { url: `data:${assertSupportedImageMimeType(block.mimeType)};base64,${block.data}` }
-	} : {
-		type: "text",
-		text: block.text
-	});
-}
-/**
-* Translates VernLLM's provider-agnostic `messages` (the one part of a
-* request that isn't a pure passthrough for OpenAI-compatible clients) into
-* OpenAI's native wire shape. Shared between `create` and `createStream` so
-* both go through identical message translation.
-*/
-function toOpenAIMessages(params) {
-	return params.messages.map((m) => {
-		if (m.role === "user" && Array.isArray(m.content)) return {
-			...m,
-			content: toOpenAIContent(m.content)
-		};
-		if (m.role === "tool") {
-			const { is_error: _isError,...openAIToolMessage } = m;
-			return openAIToolMessage;
-		}
-		return m;
-	});
-}
-/**
-* Translates one OpenAI-shaped SSE chunk into zero or more `WireStreamChunk`s.
-* A single chunk can carry a text delta, one or more tool-call argument
-* deltas (each keyed by `index`, OpenAI's own convention for streaming
-* parallel tool calls, mirrored directly by VernLLM's `tool_call_delta`
-* shape so accumulation composes without translation), and/or a final
-* usage block (present only when `stream_options.include_usage` is set,
-* which this adapter always sets).
-*/
-function* toWireStreamChunks(chunk) {
-	const delta = chunk.choices?.[0]?.delta;
-	if (delta?.content) yield {
-		type: "text-delta",
-		delta: delta.content
-	};
-	if (delta?.tool_calls?.length) for (const toolCall of delta.tool_calls) yield {
-		type: "tool_call_delta",
-		index: toolCall.index,
-		id: toolCall.id,
-		name: toolCall.function?.name,
-		argumentsDelta: toolCall.function?.arguments
-	};
-	if (chunk.usage) yield {
-		type: "usage",
-		usage: chunk.usage
-	};
-}
-function fromOpenAICompatible(client, options = {}) {
-	const raw = client;
-	const { supportsStreamUsage = true } = options;
-	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({
-				...params,
-				messages
-			}, options$1);
-		},
-		async *createStream(params, options$1) {
-			const messages = toOpenAIMessages(params);
-			const stream = await rawCreate({
-				...params,
-				messages,
-				stream: true,
-				...supportsStreamUsage ? { stream_options: { include_usage: true } } : {}
-			}, options$1);
-			for await (const chunk of stream) yield* toWireStreamChunks(chunk);
-		}
-	} } };
-}
-/**
-* Named alias for the OpenAI SDK itself. A raw `new OpenAI(...)` instance
-* structurally matches most of `LLMClient`, but newer `openai` SDK major
-* versions have widened `ChatCompletionContentPart` (e.g. adding a `file`
-* variant) in ways that no longer structurally satisfy VernLLM's
-* provider-agnostic `ContentBlock[]` on `userContent`, so passing the SDK
-* instance directly can fail to typecheck depending on the installed
-* `openai` version. Wrapping with `fromOpenAI()` (a plain alias of
-* `fromOpenAICompatible()`) sidesteps that by translating through
-* `unknown` at the boundary, and also picks up multimodal image
-* translation and `createStream` wiring that a raw client doesn't have.
-* See Migration Notes for details.
-*/
-const fromOpenAI = fromOpenAICompatible;
-/** Groqs SDK matches the OpenAI wire format */
-const fromGroq = fromOpenAICompatible;
-/**
-* Mistrals `chat.completions`-shaped client (or their OpenAI-compat
-* endpoint). Mistral supports `stream_options.include_usage` (added after
-* an earlier period where it returned a 422 for unrecognized fields, per
-* Mistral's changelog and streaming docs), so this is a plain alias like
-* the others, `supportsStreamUsage` defaults to `true`.
-*/
-const fromMistral = fromOpenAICompatible;
-/** DeepSeeks API is OpenAI-compatible */
-const fromDeepSeek = fromOpenAICompatible;
-/** Cerebras inference API is OpenAI-compatible */
-const fromCerebras = fromOpenAICompatible;
-/** Together AIs API is OpenAI-compatible */
-const fromTogether = fromOpenAICompatible;
-/** Fireworks AIs API is OpenAI-compatible */
-const fromFireworks = fromOpenAICompatible;
-/**
-* Ollama exposes an OpenAI-compatible endpoint at `/v1/chat/completions`
-* (as opposed to its native `/api/chat` format, which differs). Point an
-* OpenAI SDK instances `baseURL` at your Ollama server and pass it here:
-* this does not talk to Ollamas native API directly.
-*/
-const fromOllama = fromOpenAICompatible;
-/** OpenRouter's API is OpenAI-compatible */
-const fromOpenRouter = fromOpenAICompatible;
-/** Perplexity's API is OpenAI-compatible */
-const fromPerplexity = fromOpenAICompatible;
-/** DeepInfra's API is OpenAI-compatible */
-const fromDeepInfra = fromOpenAICompatible;
-/** Novita's API is OpenAI-compatible */
-const fromNovita = fromOpenAICompatible;
-/** Hyperbolic's API is OpenAI-compatible */
-const fromHyperbolic = fromOpenAICompatible;
-/** Moonshot's (Kimi) API is OpenAI-compatible */
-const fromMoonshot = fromOpenAICompatible;
-/** Zhipu's (GLM) API is OpenAI-compatible */
-const fromZhipu = fromOpenAICompatible;
-/**
-* LM Studio exposes an OpenAI-compatible endpoint at `/v1/chat/completions`.
-* Point an OpenAI SDK instance's `baseURL` at your local LM Studio server.
-*/
-const fromLMStudio = fromOpenAICompatible;
-/**
-* vLLM's OpenAI-compatible server mode exposes `/v1/chat/completions`.
-* Point an OpenAI SDK instance's `baseURL` at your vLLM server.
-*/
-const fromVLLM = fromOpenAICompatible;
-/** xAI's Grok API is OpenAI-compatible */
-const fromXAI = fromOpenAICompatible;
-/** NVIDIA NIM's hosted and self-hosted endpoints are OpenAI-compatible */
-const fromNvidiaNIM = fromOpenAICompatible;
-/** Vercel AI Gateway is OpenAI-compatible */
-const fromVercelAIGateway = fromOpenAICompatible;
-/** Cloudflare Workers AI exposes an OpenAI-compatible endpoint */
-const fromCloudflareWorkersAI = fromOpenAICompatible;
-/** Nebius AI Studio is OpenAI-compatible */
-const fromNebius = fromOpenAICompatible;
-/** SambaNova Cloud's API is OpenAI-compatible */
-const fromSambaNova = fromOpenAICompatible;
-/** Baseten's model hosting exposes an OpenAI-compatible endpoint */
-const fromBaseten = fromOpenAICompatible;
-/** Featherless AI's API is OpenAI-compatible */
-const fromFeatherless = fromOpenAICompatible;
-/** Friendli AI's serving endpoint is OpenAI-compatible */
-const fromFriendli = fromOpenAICompatible;
-/** SiliconFlow's API is OpenAI-compatible */
-const fromSiliconFlow = fromOpenAICompatible;
-/** Parasail's inference API is OpenAI-compatible */
-const fromParasail = fromOpenAICompatible;
-/** StepFun's API is OpenAI-compatible */
-const fromStepFun = fromOpenAICompatible;
-/** MiniMax's API is OpenAI-compatible */
-const fromMiniMax = fromOpenAICompatible;
-/** Lambda Labs' Inference API is OpenAI-compatible */
-const fromLambdaLabs = fromOpenAICompatible;
-/** Snowflake Cortex's LLM endpoint is OpenAI-compatible */
-const fromSnowflakeCortex = fromOpenAICompatible;
-/** Anyscale Endpoints' API is OpenAI-compatible */
-const fromAnyscale = fromOpenAICompatible;
-/** Lepton AI's inference API is OpenAI-compatible */
-const fromLepton = fromOpenAICompatible;
-/** Inference.net's API is OpenAI-compatible */
-const fromInferenceNet = fromOpenAICompatible;
-/** Infermatic's API is OpenAI-compatible */
-const fromInfermatic = fromOpenAICompatible;
-/** AtlasCloud's inference API is OpenAI-compatible */
-const fromAtlasCloud = fromOpenAICompatible;
-/** 01.AI's (Yi models) API is OpenAI-compatible */
-const from01AI = fromOpenAICompatible;
-
-//#endregion
-export { CircuitBreaker, ConsoleLogger, FallbackExhaustedError, InMemoryCacheAdapter, LLMError, NormalizedCacheAdapter, RateLimiter, SSE_PING, TieredCacheAdapter, VernLLM, defaultEstimateTokens, defaultFallbackOn, from01AI, fromAnthropic, fromAnyscale, fromAtlasCloud, fromBaseten, fromBedrock, fromCerebras, fromCloudflareWorkersAI, fromDeepInfra, fromDeepSeek, fromFeatherless, fromFetch, fromFireworks, fromFriendli, fromGemini, fromGroq, fromHyperbolic, fromInferenceNet, fromInfermatic, fromLMStudio, fromLambdaLabs, fromLepton, fromMiniMax, fromMistral, fromMoonshot, fromNebius, fromNovita, fromNvidiaNIM, fromOllama, fromOpenAI, fromOpenAICompatible, fromOpenRouter, fromParasail, fromPerplexity, fromSambaNova, fromSiliconFlow, fromSnowflakeCortex, fromStepFun, fromTogether, fromVLLM, fromVercelAIGateway, fromXAI, fromZhipu, hasIssues, isFallbackExhaustedError, isLLMError, isToolCallResult, parseSseStream };
+`)}let i=n.trim();if(i){let e=G(i);e!==H&&e!==U&&(yield e)}}const H=Symbol(`sse-stream-done`),U=Symbol(`sse-frame-no-data`),W=Symbol(`sse-frame-ping`);function G(e){let t=[],n=!1;for(let r of e.split(`
+`)){if(r.startsWith(`:`)){n=!0;continue}if(!r.startsWith(`data:`))continue;t.push(r.startsWith(`data: `)?r.slice(6):r.slice(5))}if(!t.length)return n?W:U;let r=t.join(`
+`);if(r===`[DONE]`)return H;try{return JSON.parse(r)}catch(e){throw new f(`Invalid JSON in SSE frame: ${r.slice(0,200)}`,`parse`,{cause:e,code:`stream_frame_invalid`})}}const K=[`image/png`,`image/jpeg`,`image/gif`,`image/webp`];function q(e){if(K.includes(e))return e;throw new f(`Unsupported image mimeType "${e}": expected one of ${K.join(`, `)}`,`invalid_params`)}function Ie(e,t){return t?Array.isArray(t)?t.includes(e):t(e):!1}const J={minimal:1024,low:4096,medium:16e3,high:32e3};function Y(e){if(!e)return J;let t={...J,...e};if(!(t.minimal<t.low&&t.low<t.medium&&t.medium<t.high))throw new f(`reasoningEffortTokens must keep tiers in strictly ascending order (minimal < low < medium < high), got ${JSON.stringify(t)}. An out-of-order override doesn't just misrank tiers, it can make some of them unreachable.`,`invalid_params`);return t}function X(e,t=J){return t[e]}function Z(e,t=J){return e<=t.minimal?`minimal`:e<=t.low?`low`:e<=t.medium?`medium`:`high`}function Le(e){let t=/opus-(\d+)(?:-(\d+))?/.exec(e);if(!t)return null;let n=t[2],r=n===void 0||n.length>=8?0:Number(n);return[Number(t[1]),r]}function Re(e){let t=Le(e);if(t){let[e,n]=t;return e>4||e===4&&n>=7}return[`sonnet-5`,`fable-5`,`mythos`].some(t=>e.includes(t))}function ze(e,t){return Re(e)?!0:t?Array.isArray(t)?t.includes(e):t(e):!1}function Be(e,t){return!ze(e,t)}function Ve(e,t){if(e<1024)throw new f(`budgetTokens (${e}) 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(e>=t)throw new f(`budgetTokens (${e}) must be less than maxTokens (${t}); the thinking budget and the reply share the same max_tokens ceiling on Anthropic. Raise maxTokens, or lower budgetTokens/reasoningEffort.`,`invalid_params`)}function He(e){if(e)throw new f(`budgetTokens/reasoningEffort was set alongside ${e}. 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`)}function Ue(e){return e===`minimal`?`low`:e}function We(e,t){return Ke(t,e.toUpperCase())}function Ge(e){let t=/gemini-\d+\.(\d+)/.exec(e);return t?Number(t[1]):0}function Ke(e,t){if(!e.includes(`pro`))return t;let n=qe(e);if(n===null||n<3)return t;let r=Ge(e);return r===0?t===`HIGH`?`HIGH`:`LOW`:t===`MINIMAL`?`LOW`:t}function qe(e){let t=/gemini-(\d+)/.exec(e);return t?Number(t[1]):null}function Je(e){let t=qe(e);return t!==null&&t>=3}function Ye(e,t){return Je(e)?!0:t?Array.isArray(t)?t.includes(e):t(e):!1}function Xe(e){return e.map(e=>e.type===`image`?{type:`image`,source:{type:`base64`,media_type:q(e.mimeType),data:e.data}}:{type:`text`,text:e.text})}function Ze(e,t){if(e.type!==`object`)throw new f(`Tool "${t}"'s schema must have "type": "object" (Anthropic requires object-shaped tool parameters).`,`validation`);return e}function Qe(e){return!e||e===`auto`?{type:`auto`}:e===`none`?{type:`none`}:e===`required`?{type:`any`}:{type:`tool`,name:e.function.name}}function Q(e,t){return{tools:e.map(e=>({name:e.function.name,description:e.function.description,input_schema:Ze(e.function.parameters,e.function.name)})),toolChoice:Qe(t)}}function $e(e,t,n,r){let i=e.messages.find(e=>e.role===`system`),a=e.messages.filter(e=>e.role===`user`||e.role===`assistant`||e.role===`tool`),o=e.response_format?.type===`json_schema`?e.response_format.json_schema:void 0,s=o?.name.trim();if(o&&!s)throw new f(`json_schema.name must not be empty.`,`validation`);let c=!!o&&Ie(e.model,t);if(o&&e.tools?.length&&!c)throw new f(`Anthropic model "${e.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(e.response_format?.type===`json_object`)throw new f('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 l,u,d,p;if(o&&c)u={type:`json_schema`,schema:o.schema},e.tools?.length&&({tools:d,toolChoice:p}=Q(e.tools,e.tool_choice));else if(o&&s){let{schema:e,description:t,strict:n}=o;l=s,d=[{name:l,description:t,input_schema:Ze(e,l),strict:n}],p={type:`tool`,name:l}}!o&&e.tools?.length&&({tools:d,toolChoice:p}=Q(e.tools,e.tool_choice));let m,h;if(e.budget_tokens!==void 0||e.reasoning_effort!==void 0)if(He(p?.type===`tool`?`toolChoice forcing the "${p.name}" tool`:p?.type===`any`?`toolChoice: 'required' (Anthropic's "any" tool_choice)`:void 0),Be(e.model,r)){let t=e.budget_tokens??X(e.reasoning_effort,n);Ve(t,e.max_tokens),m={type:`enabled`,budget_tokens:t}}else{let t=e.reasoning_effort??Z(e.budget_tokens,n);m={type:`adaptive`},h=Ue(t)}let g=i?.content,_=m?void 0:e.temperature,v={model:e.model,max_tokens:e.max_tokens,..._===void 0?{}:{temperature:_},system:g||void 0,messages:tt(a.map(e=>nt(e))),...d?{tools:d,tool_choice:p}:{},...u||h?{output_config:{...u?{format:u}:{},...h?{effort:h}:{}}}:{},...m?{thinking:m}:{}};return{body:v,toolName:l}}function et(e,t){let n=t?.nativeStructuredOutputModels,r=Y(t?.reasoningEffortTokens),i=t?.adaptiveOnlyModels,a=e.messages.create.bind(e.messages);return{supportsJsonObjectMode:!1,chat:{completions:{async create(t,a){let{body:o,toolName:s}=$e(t,n,r,i),c=await e.messages.create(o,a),l,u;if(s){let e=c.content.find(e=>e.type===`tool_use`&&e.name===s);if(!e)throw new f(`Anthropic did not return the required structured output tool "${s}".`,`validation`);if(!e.input||typeof e.input!=`object`||Array.isArray(e.input))throw new f(`Anthropic returned invalid structured output for tool "${s}". Expected an object.`,`validation`);l=JSON.stringify(e.input)}else{l=c.content.filter(e=>e.type===`text`).map(e=>e.text??``).join(``);let e=c.content.filter(e=>e.type===`tool_use`);e.length&&(u=e.map(e=>({id:e.id,type:`function`,function:{name:e.name,arguments:JSON.stringify(e.input??{})}})))}return{choices:[{message:{content:l,...u?{tool_calls:u}:{}}}],usage:{prompt_tokens:c.usage?.input_tokens,completion_tokens:c.usage?.output_tokens,total_tokens:(c.usage?.input_tokens??0)+(c.usage?.output_tokens??0),...c.usage?.output_tokens_details?.thinking_tokens===void 0?{}:{completion_tokens_details:{reasoning_tokens:c.usage.output_tokens_details.thinking_tokens}}}}},async*createStream(e,t){let{body:o,toolName:s}=$e(e,n,r,i),c=await a({...o,stream:!0},t),l=new Map,u=0,d=!1;for await(let e of c)if(e.type===`message_start`)u=e.message.usage?.input_tokens??0;else if(e.type===`content_block_start`)if(e.content_block.type===`tool_use`){let t=e.content_block.name===s?`json-tool`:`tool_use`;l.set(e.index,t),t===`json-tool`?d=!0:s||(yield{type:`tool_call_delta`,index:e.index,id:e.content_block.id,name:e.content_block.name})}else l.set(e.index,`text`);else if(e.type===`content_block_delta`){if(e.delta.type===`text_delta`)s||(yield{type:`text-delta`,delta:e.delta.text});else if(e.delta.type===`input_json_delta`){let t=l.get(e.index);t===`json-tool`?yield{type:`text-delta`,delta:e.delta.partial_json}:s||(yield{type:`tool_call_delta`,index:e.index,argumentsDelta:e.delta.partial_json})}}else if(e.type===`message_delta`){let t=e.usage?.output_tokens??0,n=e.usage?.output_tokens_details?.thinking_tokens;yield{type:`usage`,usage:{prompt_tokens:u,completion_tokens:t,total_tokens:u+t,...n===void 0?{}:{completion_tokens_details:{reasoning_tokens:n}}}}}else e.type===`ping`&&(yield{type:`ping`});if(s&&!d)throw new f(`Anthropic did not return the required structured output tool "${s}".`,`validation`)}}}}}function tt(e){let t=e=>e.role===`user`&&Array.isArray(e.content)&&e.content.length>0&&e.content.every(e=>e.type===`tool_result`),n=[];for(let r of e){let e=n.at(-1);t(r)&&e&&t(e)?e.content.push(...r.content):n.push(r)}return n}function nt(e){if(e.role===`tool`)return{role:`user`,content:[{type:`tool_result`,tool_use_id:e.tool_call_id,content:e.content,...e.is_error?{is_error:!0}:{}}]};if(e.role===`assistant`&&e.tool_calls?.length){let t=[];e.content&&t.push({type:`text`,text:e.content});for(let n of e.tool_calls){let e;try{e=n.function.arguments.trim()?JSON.parse(n.function.arguments):{}}catch(e){throw new f(`Assistant tool call "${n.function.name}" (${n.id}) has arguments that are not valid JSON.`,`validation`,{cause:e})}if(e===null||Array.isArray(e)||typeof e!=`object`)throw new f(`Assistant tool call "${n.function.name}" (${n.id}) arguments must be a JSON object.`,`validation`);t.push({type:`tool_use`,id:n.id,name:n.function.name,input:e})}return{role:`assistant`,content:t}}return{role:e.role,content:Array.isArray(e.content)?Xe(e.content):e.content??``}}function rt(e){return e.map(e=>e.type===`image`?{inlineData:{mimeType:q(e.mimeType),data:e.data}}:{text:e.text})}function it(e){return!e||e===`auto`?{functionCallingConfig:{mode:`AUTO`}}:e===`none`?{functionCallingConfig:{mode:`NONE`}}:e===`required`?{functionCallingConfig:{mode:`ANY`}}:{functionCallingConfig:{mode:`ANY`,allowedFunctionNames:[e.function.name]}}}function at(e){if(e.role===`tool`)return{role:`user`,parts:[{functionResponse:{name:e.tool_call_id,response:st(e.content)}}]};if(e.role===`assistant`&&e.tool_calls?.length){let t=[];return typeof e.content==`string`&&e.content&&t.push({text:e.content}),t.push(...e.tool_calls.map(e=>({functionCall:{name:e.function.name,args:ot(e.function.arguments,e.function.name)}}))),{role:`model`,parts:t}}return{role:e.role===`assistant`?`model`:`user`,parts:Array.isArray(e.content)?rt(e.content):[{text:e.content??``}]}}function ot(e,t){let n;try{n=e.trim()?JSON.parse(e):{}}catch(e){throw new f(`Tool call "${t}" arguments are not valid JSON.`,`parse`,{cause:e,code:`tool_arguments_parse_failed`})}if(!n||Array.isArray(n)||typeof n!=`object`)throw new f(`Tool call "${t}" arguments must be a JSON object.`,`validation`);return n}function st(e){let t;try{t=e.trim()?JSON.parse(e):``}catch{t=e}return t&&!Array.isArray(t)&&typeof t==`object`?t:{output:t}}function ct(e){let t=e=>e.role===`user`&&e.parts.length>0&&e.parts.every(e=>`functionResponse`in e),n=[];for(let r of e){let e=n.at(-1);t(r)&&e&&t(e)?e.parts.push(...r.parts):n.push(r)}return n}function lt(e,t,n){let r=e.messages.find(e=>e.role===`system`),i=e.messages.filter(e=>e.role===`user`||e.role===`assistant`||e.role===`tool`),a=!!e.response_format,o={...e.temperature===void 0?{}:{temperature:e.temperature},maxOutputTokens:e.max_tokens,...r?{systemInstruction:{parts:[{text:r.content}]}}:{}};if(a&&(o.responseMimeType=`application/json`),e.response_format?.type===`json_schema`){let{schema:t,description:n}=e.response_format.json_schema;o.responseSchema={...t,...n?{description:n}:{}}}if(e.tools?.length&&(o.tools=[{functionDeclarations:e.tools.map(e=>({name:e.function.name,description:e.function.description,parameters:e.function.parameters}))}],o.toolConfig=it(e.tool_choice)),Ye(e.model,n)){let n=e.reasoning_effort??(e.budget_tokens===void 0?void 0:Z(e.budget_tokens,t));n!==void 0&&(o.thinkingConfig={thinkingLevel:We(n,e.model)})}else{let n=e.budget_tokens??(e.reasoning_effort?X(e.reasoning_effort,t):void 0);n!==void 0&&(o.thinkingConfig={thinkingBudget:n})}return{model:e.model,contents:ct(i.map(e=>at(e))),config:o}}function ut(e,t){let n=Y(t?.reasoningEffortTokens),r=t?.thinkingLevelModels,i=e.models??e;if(typeof i.generateContent!=`function`)throw new f(`fromGemini requires a client with generateContent: pass ai.models, or the whole ai client (fromGemini(ai)).`,`invalid_params`,{code:`unsupported_capability`,issues:{capability:`generateContent`}});let a=i.generateContent.bind(i),o=typeof i.generateContentStream==`function`?i.generateContentStream.bind(i):void 0;return{chat:{completions:{async create(e,t){let i=lt(e,n,r);i.config={...i.config,abortSignal:t.signal};let o=await a(i),s=o.candidates?.[0]?.content?.parts??[],c=s.map(e=>e.text??``).join(``),l=s.filter(e=>e.functionCall),u;return l.length&&(u=l.map(e=>({id:e.functionCall.name,type:`function`,function:{name:e.functionCall.name,arguments:JSON.stringify(e.functionCall.args??{})}}))),{choices:[{message:{content:c,...u?{tool_calls:u}:{}}}],usage:{prompt_tokens:o.usageMetadata?.promptTokenCount,completion_tokens:o.usageMetadata?.candidatesTokenCount,total_tokens:o.usageMetadata?.totalTokenCount,...o.usageMetadata?.thoughtsTokenCount===void 0?{}:{completion_tokens_details:{reasoning_tokens:o.usageMetadata.thoughtsTokenCount}}}}},async*createStream(e,t){if(!o)throw new f(`stream: true requires a Gemini client with generateContentStream`,`invalid_params`,{code:`unsupported_capability`,issues:{capability:`generateContentStream`}});let i=lt(e,n,r);i.config={...i.config,abortSignal:t.signal};let a=await o(i),s=0,c;for await(let e of a){let t=e.candidates?.[0]?.content?.parts??[];for(let e of t)e.text&&(yield{type:`text-delta`,delta:e.text}),e.functionCall&&(yield{type:`tool_call_delta`,index:s,id:e.functionCall.name,name:e.functionCall.name,argumentsDelta:JSON.stringify(e.functionCall.args??{}),complete:!0},s++);e.usageMetadata&&(c=e.usageMetadata)}c&&(yield{type:`usage`,usage:{prompt_tokens:c.promptTokenCount,completion_tokens:c.candidatesTokenCount,total_tokens:c.totalTokenCount,...c.thoughtsTokenCount===void 0?{}:{completion_tokens_details:{reasoning_tokens:c.thoughtsTokenCount}}}})}}}}}function dt(e){return e.includes(`claude`)}function ft(e){switch(q(e)){case`image/png`:return`png`;case`image/jpeg`:return`jpeg`;case`image/gif`:return`gif`;case`image/webp`:return`webp`}}function pt(e){return new Uint8Array(Buffer.from(e,`base64`))}function mt(e){return e.map(e=>e.type===`image`?{image:{format:ft(e.mimeType),source:{bytes:pt(e.data)}}}:{text:e.text})}function ht(e,t){return{tools:e.map(e=>({toolSpec:{name:e.function.name,description:e.function.description,inputSchema:{json:e.function.parameters}}})),toolChoice:St(t)}}function gt(e,t,n,r,i){let a=e.messages.find(e=>e.role===`system`),o=e.messages.filter(e=>e.role===`user`||e.role===`assistant`||e.role===`tool`),s=e.response_format?.type===`json_schema`?e.response_format.json_schema:void 0,c=s?.name.trim();if(s&&!c)throw new f(`json_schema.name must not be empty.`,`validation`);let l=!!s&&Ie(e.model,n);if(s&&e.tools?.length&&!l)throw new f(`Bedrock model "${e.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(e.response_format?.type===`json_object`)throw new f('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 u,d,p;if(s&&l){let{schema:e,description:t}=s;p={textFormat:{type:`json_schema`,structure:{jsonSchema:{schema:JSON.stringify(e),name:c,description:t}}}}}else if(s&&c){let{schema:e,description:t,strict:n}=s;u=c,d={tools:[{toolSpec:{name:u,description:t,inputSchema:{json:e},strict:n}}],toolChoice:{tool:{name:u}}}}if(e.tools?.length&&!u&&(d=ht(e.tools,e.tool_choice)),s&&d&&t){let n=Array.isArray(t)?t.includes(e.model):t(e.model);if(!n)throw new f(`Bedrock model "${e.model}" is not listed in toolUseSupportedModels, but this call requires Converse tool use (either jsonSchema emulated as a forced tool call, or real \`tools\` sent alongside native structured output).`,`invalid_params`,{code:`unsupported_capability`,issues:{capability:`toolUseSupportedModels`}})}let m,h;if(dt(e.model)&&(e.budget_tokens!==void 0||e.reasoning_effort!==void 0)){let t=d?.toolChoice;if(He(t&&`tool`in t?`toolChoice forcing the "${t.tool?.name}" tool`:t&&`any`in t?`toolChoice: 'required' (Converse's "any" tool_choice)`:void 0),Be(e.model,i)){let t=e.budget_tokens??X(e.reasoning_effort,r);Ve(t,e.max_tokens),m={thinking:{type:`enabled`,budget_tokens:t}}}else{let t=e.reasoning_effort??Z(e.budget_tokens,r);m={thinking:{type:`adaptive`}},h=Ue(t)}}let g=m?void 0:e.temperature,_={modelId:e.model,messages:wt(o.map(e=>Ct(e))),system:a?.content?[{text:a.content}]:void 0,inferenceConfig:{...g===void 0?{}:{temperature:g},maxTokens:e.max_tokens},...d?{toolConfig:d}:{},...p||h?{outputConfig:{...p??{},...h?{effort:h}:{}}}:{},...m?{additionalModelRequestFields:m}:{}};return{request:_,toolName:u}}function _t(e){return typeof e.send==`function`}function vt(e){if(`messageStart`in e)return{messageStart:e.messageStart};if(`contentBlockStart`in e)return{contentBlockStart:e.contentBlockStart};if(`contentBlockDelta`in e)return{contentBlockDelta:e.contentBlockDelta};if(`contentBlockStop`in e)return{contentBlockStop:e.contentBlockStop};if(`messageStop`in e)return{messageStop:e.messageStop};if(`metadata`in e)return{metadata:e.metadata};if(`internalServerException`in e)return{internalServerException:e.internalServerException};if(`modelStreamErrorException`in e)return{modelStreamErrorException:e.modelStreamErrorException};if(`validationException`in e)return{validationException:e.validationException};if(`throttlingException`in e)return{throttlingException:e.throttlingException};if(`serviceUnavailableException`in e)return{serviceUnavailableException:e.serviceUnavailableException}}async function*yt(e){for await(let t of e){let e=vt(t);e&&(yield e)}}function bt(e){let t;function n(){return t??=import(`@aws-sdk/client-bedrock-runtime`).then(e=>e,e=>{throw t=void 0,new f(`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:e})}),t}return{converse:async(t,r)=>{let{ConverseCommand:i}=await n();return e.send(new i(t),{abortSignal:r.signal})},converseStream:async(t,r)=>{let{ConverseStreamCommand:i}=await n(),a=await e.send(new i(t),{abortSignal:r.signal});if(!a.stream)throw new f(`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:yt(a.stream)}}}}function xt(e,t){let n=_t(e)?bt(e):e,r=t?.toolUseSupportedModels,i=t?.nativeStructuredOutputModels,a=Y(t?.reasoningEffortTokens),o=t?.adaptiveOnlyModels;return{supportsJsonObjectMode:!1,chat:{completions:{async create(e,t){let{request:s,toolName:c}=gt(e,r,i,a,o),l=await n.converse(s,t),u,d;if(c){let e=l.output?.message?.content?.find(e=>e.toolUse?.name===c);u=e?.toolUse?JSON.stringify(e.toolUse.input):``}else{let e=l.output?.message?.content??[];u=e.map(e=>e.text??``).join(``);let t=e.filter(e=>!!e.toolUse);t.length&&(d=t.map((e,t)=>{let n=e.toolUse;if(!n.name)throw new f(`Bedrock returned a toolUse block without a name at index ${t}.`,`validation`);return{id:n.toolUseId??`${n.name}_${t}`,type:`function`,function:{name:n.name,arguments:JSON.stringify(n.input??{})}}}))}return{choices:[{message:{content:u,...d?{tool_calls:d}:{}}}],usage:{prompt_tokens:l.usage?.inputTokens,completion_tokens:l.usage?.outputTokens,total_tokens:l.usage?.totalTokens}}},async*createStream(e,t){if(!n.converseStream)throw new f(`stream: true requires a Bedrock client with converseStream`,`invalid_params`,{code:`unsupported_capability`,issues:{capability:`converseStream`}});let{request:s,toolName:c}=gt(e,r,i,a,o),{stream:l}=await n.converseStream(s,t),u=new Map;for await(let e of l)if(`contentBlockStart`in e){let{contentBlockIndex:t,start:n}=e.contentBlockStart;if(n?.toolUse){let e=n.toolUse.name===c?`json-tool`:`tool_use`;u.set(t,e),e===`tool_use`&&!c&&(yield{type:`tool_call_delta`,index:t,id:n.toolUse.toolUseId,name:n.toolUse.name})}else u.set(t,`text`)}else if(`contentBlockDelta`in e){let{contentBlockIndex:t,delta:n}=e.contentBlockDelta;if(n&&`text`in n&&n.text!==void 0&&!c)yield{type:`text-delta`,delta:n.text};else if(n&&`toolUse`in n&&n.toolUse?.input!==void 0){let e=u.get(t);e===`json-tool`?yield{type:`text-delta`,delta:n.toolUse.input}:c||(yield{type:`tool_call_delta`,index:t,argumentsDelta:n.toolUse.input})}}else if(`metadata`in e&&e.metadata.usage)yield{type:`usage`,usage:{prompt_tokens:e.metadata.usage.inputTokens,completion_tokens:e.metadata.usage.outputTokens,total_tokens:e.metadata.usage.totalTokens}};else if(`throttlingException`in e)throw new f(e.throttlingException.message??`Bedrock throttled the request mid-stream`,`api`,{status:429,code:`provider_rate_limited`});else if(`validationException`in e)throw new f(e.validationException.message??`Bedrock rejected the request mid-stream`,`validation`);else if(`internalServerException`in e||`serviceUnavailableException`in e||`modelStreamErrorException`in e){let t=`internalServerException`in e&&e.internalServerException.message||`serviceUnavailableException`in e&&e.serviceUnavailableException.message||`modelStreamErrorException`in e&&e.modelStreamErrorException.message||`Bedrock reported a mid-stream error`,n=`modelStreamErrorException`in e&&e.modelStreamErrorException.originalStatusCode||`serviceUnavailableException`in e&&503||500;throw new f(t,`api`,{status:n,code:n>=500?`server_error`:void 0})}}}}}}function St(e){if(!e||e===`auto`)return{auto:{}};if(e===`required`)return{any:{}};if(e===`none`)throw new f("'none' is not supported by fromBedrock: Bedrock Converse has no `tool_choice` equivalent to forbidding tool use while tools are still offered. Omit `tools` entirely for this call instead.",`invalid_params`,{code:`unsupported_capability`,issues:{capability:`toolChoice: 'none'`}});return{tool:{name:e.function.name}}}function Ct(e){if(e.role===`tool`)return{role:`user`,content:[{toolResult:{toolUseId:e.tool_call_id,content:[{text:e.content}],status:e.is_error?`error`:`success`}}]};if(e.role===`assistant`&&e.tool_calls?.length){let t=[];e.content&&t.push({text:e.content});for(let n of e.tool_calls){let e;if(!n.function.arguments.trim())e={};else try{e=JSON.parse(n.function.arguments)}catch(e){throw new f(`Assistant tool call "${n.function.name}" (${n.id}) has arguments that are not valid JSON.`,`validation`,{cause:e})}t.push({toolUse:{toolUseId:n.id,name:n.function.name,input:e}})}return{role:`assistant`,content:t}}return{role:e.role,content:Array.isArray(e.content)?mt(e.content):[{text:e.content??``}]}}function wt(e){let t=e=>e.role===`user`&&e.content.length>0&&e.content.every(e=>`toolResult`in e),n=[];for(let r of e){let e=n.at(-1);t(r)&&e&&t(e)?e.content.push(...r.content):n.push(r)}return n}async function*Tt(e){let t=e.getReader();try{for(;;){let{done:e,value:n}=await t.read();if(e)return;n&&(yield n)}}finally{try{await t.cancel()}catch{}t.releaseLock()}}async function Et(e,t){let n=await fetch(e,t);if(!n.ok){let e=await n.text().catch(()=>``),t=Error(`Fetch adapter stream request failed (${n.status}): ${e.slice(0,500)}`);throw t.status=n.status,t.headers=n.headers,t}if(!n.body)throw Error(`Fetch adapter stream request received a response with no body.`);return Tt(n.body)}async function Dt(e,t,n){let r=typeof e.url==`function`?e.url(t):e.url,i=typeof e.headers==`function`?await e.headers():e.headers,a=e.method??`POST`,o=![`GET`,`HEAD`].includes(a.toUpperCase());return{url:r,method:a,headers:o?{"Content-Type":`application/json`,...i}:{...i},...o?{body:JSON.stringify(n)}:{}}}function Ot(e){return{chat:{completions:{async create(t,n){let{url:r,method:i,headers:a,body:o}=await Dt(e,t,e.mapRequest(t)),s=e.request??fetch,c=await s(r,{method:i,headers:a,body:o,signal:n.signal});if(!c.ok){let e=await c.text().catch(()=>``),t=Error(`Fetch adapter request failed (${c.status}): ${e.slice(0,500)}`);throw t.status=c.status,t.headers=c.headers,t}let l=await c.json(),{content:u,usage:d,toolCalls:f}=e.mapResponse(l),p=f?.length?f.map(e=>({id:e.id,type:`function`,function:{name:e.name,arguments:e.arguments}})):void 0;return{choices:[{message:{content:u,...p?{tool_calls:p}:{}}}],usage:d?{prompt_tokens:d.promptTokens,completion_tokens:d.completionTokens,total_tokens:d.totalTokens}:void 0}},async*createStream(t,n){if(!e.mapStreamEvent)throw new f(`stream: true requires mapStreamEvent to be configured on fromFetch`,`invalid_params`,{code:`unsupported_capability`,issues:{capability:`mapStreamEvent`}});if(e.request&&!e.requestStream)throw new f("`stream: true` requires `requestStream` to be configured on fromFetch when a custom `request` transport is set. `requestStream` does not fall back to `request` (it needs an async-iterable byte stream, which `RequestLike`'s buffered `ResponseLike` has no way to provide), without it, `stream: true` would silently use plain native `fetch` instead of your configured transport. Add a `requestStream` that opens the same connection your `request` does, or omit `request` if native `fetch` is fine for both.",`invalid_params`,{code:`unsupported_capability`,issues:{capability:`requestStream`}});let{url:r,method:i,headers:a,body:o}=await Dt(e,t,e.mapRequest(t)),s=e.requestStream??Et,c=e.parseStreamFrames??V,l=await s(r,{method:i,headers:a,body:o,signal:n.signal});for await(let t of c(l)){if(t===W){yield{type:`ping`};continue}let n=e.mapStreamEvent(t);if(!n)continue;Array.isArray(n)?yield*n:yield n}}}}}}function kt(e,t){if(e.budget_tokens===void 0)return e;let{budget_tokens:n,...r}=e;return r.reasoning_effort===void 0?{...r,reasoning_effort:Z(n,t)}:r}function At(e){return e.map(e=>e.type===`image`?{type:`image_url`,image_url:{url:`data:${q(e.mimeType)};base64,${e.data}`}}:{type:`text`,text:e.text})}function jt(e){return e.messages.map(e=>{if(e.role===`user`&&Array.isArray(e.content))return{...e,content:At(e.content)};if(e.role===`tool`){let{is_error:t,...n}=e;return n}return e})}function*Mt(e){let t=e.choices?.[0]?.delta;if(t?.content&&(yield{type:`text-delta`,delta:t.content}),t?.tool_calls?.length)for(let e of t.tool_calls)yield{type:`tool_call_delta`,index:e.index,id:e.id,name:e.function?.name,argumentsDelta:e.function?.arguments};e.usage&&(yield{type:`usage`,usage:e.usage})}function $(e,t={}){let n=e,{supportsStreamUsage:r=!0}=t,i=Y(t.reasoningEffortTokens),a=n.chat.completions.create.bind(n.chat.completions);return{chat:{completions:{async create(e,t){let r=jt(e);return n.chat.completions.create(kt({...e,messages:r},i),t)},async*createStream(e,t){let n=jt(e),o=await a(kt({...e,messages:n,stream:!0,...r?{stream_options:{include_usage:!0}}:{}},i),t);for await(let e of o)yield*Mt(e)}}}}}const Nt=$,Pt=$,Ft=$,It=$,Lt=$,Rt=$,zt=$,Bt=$,Vt=$,Ht=$,Ut=$,Wt=$,Gt=$,Kt=$,qt=$,Jt=$,Yt=$,Xt=$,Zt=$,Qt=$,$t=$,en=$,tn=$,nn=$,rn=$,an=$,on=$,sn=$,cn=$,ln=$,un=$,dn=$,fn=$,pn=$,mn=$,hn=$,gn=$,_n=$;export{k as CircuitBreaker,L as ConsoleLogger,x as FallbackExhaustedError,h as InMemoryCacheAdapter,f as LLMError,g as NormalizedCacheAdapter,B as RateLimiter,W as SSE_PING,_ as TieredCacheAdapter,Ne as VernLLM,R as defaultEstimateTokens,b as defaultFallbackOn,Fe as defineCachedCallParams,Pe as defineCallParams,_n as from01AI,et as fromAnthropic,fn as fromAnyscale,gn as fromAtlasCloud,nn as fromBaseten,xt as fromBedrock,Lt as fromCerebras,$t as fromCloudflareWorkersAI,Ut as fromDeepInfra,It as fromDeepSeek,rn as fromFeatherless,Ot as fromFetch,zt as fromFireworks,an as fromFriendli,ut as fromGemini,Pt as fromGroq,Gt as fromHyperbolic,mn as fromInferenceNet,hn as fromInfermatic,Jt as fromLMStudio,un as fromLambdaLabs,pn as fromLepton,ln as fromMiniMax,Ft as fromMistral,Kt as fromMoonshot,en as fromNebius,Wt as fromNovita,Zt as fromNvidiaNIM,Bt as fromOllama,Nt as fromOpenAI,$ as fromOpenAICompatible,Vt as fromOpenRouter,sn as fromParasail,Ht as fromPerplexity,tn as fromSambaNova,on as fromSiliconFlow,dn as fromSnowflakeCortex,cn as fromStepFun,Rt as fromTogether,Yt as fromVLLM,Qt as fromVercelAIGateway,Xt as fromXAI,qt as fromZhipu,m as hasIssues,S as isFallbackExhaustedError,p as isLLMError,v as isToolCallResult,V as parseSseStream};
 //# sourceMappingURL=index.js.map