opencode-navigator 0.20.0 → 0.21.1

package/dist/server.js

@@ -43,6 +43,592 @@ var NavigatorTodoRpc={id:"opencode-navigator.todo",methods:{list:{input:{type:"o
 },output
 }},events:{updated:{schema:{type:"object",properties:{sessionID,todos,guidance:{type:"boolean"}},required:["sessionID","todos","guidance"],additionalProperties:false
 }}}};
+var text={type:"string",minLength:1,maxLength:512}
+var model={type:"object",properties:{providerID:text,modelID:text,sessionID:text,connectionID:text,variant:text,force:{type:"boolean"}},required:["providerID","modelID","sessionID"],additionalProperties:false
+}
+var NavigatorQuotaRpc={id:"opencode-navigator.quotas",methods:{read:{input:model,output:{type:"object",additionalProperties:true}},capabilities:{input:{type:"object",additionalProperties:false},output:{type:"array",items:{type:"object",additionalProperties:true}}}},events:{updated:{schema:{type:"object",properties:{providerID:text,modelID:text},required:["providerID","modelID"],additionalProperties:false
+}}}};
+function normalizeProviderQuota(snapshot){if(!snapshot.providerId||!snapshot.providerName||!snapshot.model.providerID||!snapshot.model.modelID||!snapshot.model.sessionID||!Number.isFinite(snapshot.fetchedAt)){throw new Error("Invalid provider quota identity")
+}
+const windows=snapshot.windows.map((window)=>{if(!window.id||!window.label||window.scope!==undefined&&window.scope!=="account"&&window.scope!=="model"||(window.scope==="account"?!snapshot.accountId||window.modelID!==undefined:window.modelID!==snapshot.model.modelID)||!window.unit||window.used!==undefined&&!Number.isFinite(window.used)||window.remaining!==undefined&&!Number.isFinite(window.remaining)||window.used===undefined&&window.remaining===undefined&&window.total===undefined||window.total!==undefined&&(!Number.isFinite(window.total)||window.total<0)||window.durationMinutes!==undefined&&(!Number.isFinite(window.durationMinutes)||window.durationMinutes<0)||window.resetsAt!==undefined&&!Number.isFinite(window.resetsAt)){throw new Error("Quota window does not match the selected model or contains invalid values")
+}
+return{...window}})
+const bankedResets=snapshot.bankedResets
+const balances=snapshot.balances?.map((balance)=>{if(!balance.id||!balance.label||balance.scope!=="account"&&balance.scope!=="key"||balance.amount===undefined&&!balance.unlimited||balance.amount!==undefined&&(typeof balance.amount!=="string"||!/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(balance.amount)||!Number.isFinite(Number(balance.amount)))||balance.unit!==undefined&&(typeof balance.unit!=="string"||!balance.unit))
+throw new Error("Invalid provider balance")
+return{...balance}})
+if(bankedResets&&(!Number.isSafeInteger(bankedResets.availableCount)||bankedResets.availableCount<0)){throw new Error("Invalid banked reset count")
+}
+return{...snapshot,windows,...balances&&{balances},...bankedResets&&{bankedResets:{availableCount:bankedResets.availableCount,...bankedResets.credits&&{credits:[...bankedResets.credits]}}}}}
+var rows=[["openai","OpenAI / Codex",["subscription","api-rate-limits"],"Verified Codex account quota shared across models; HTTP response request/token limits for API connections.","https://developers.openai.com/api/docs/guides/rate-limits"],["anthropic","Anthropic / Claude",["api-rate-limits","configured-limits"],"Model HTTP headers; eligible organization/admin credentials can read configured model limits. Claude subscription windows are separate.","https://platform.claude.com/docs/en/manage-claude/rate-limits-api"],["openrouter","OpenRouter",["key-budget","account-balance"],"Inference-key budget; account credits require a management key. Free-model request limits apply only to free variants.","https://openrouter.ai/docs/api/api-reference/api-keys/get-current-api-key"],["deepseek","DeepSeek",["account-balance"],"Provider-reported USD/CNY available, granted and topped-up balances.","https://api-docs.deepseek.com/api/get-user-balance"],["moonshotai","Moonshot / Kimi API",["account-balance"],"International USD balances; coding subscriptions are a different product.","https://platform.moonshot.ai/docs/api/balance"],["moonshotai-cn","Moonshot / Kimi API China",["account-balance"],"China CNY balances; never reuse an international key against the China endpoint.","https://platform.moonshot.cn/docs/api/balance"],["minimax","MiniMax",["subscription","account-balance"],"Token Plan model rows/explicit percentages; official SDK balance response for pay-as-you-go keys.","https://platform.minimax.io/docs/token-plan/faq"],["minimax-cn","MiniMax China",["subscription","account-balance"],"Region-specific native Token Plan and SDK balance endpoints.","https://github.com/MiniMax-AI/cli/tree/main/src/sdk/quota"],["github-copilot","GitHub Copilot",["subscription"],"Official SDK token-scoped quota/model RPC; no direct copilot_internal calls or ambient CLI login.","https://github.com/github/copilot-sdk/blob/main/docs/features/usage-and-billing.md"],["groq","Groq",["api-rate-limits"],"Native model response headers: requests per day and tokens per minute.","https://console.groq.com/docs/rate-limits"],["fireworks-ai","Fireworks",["configured-limits","api-rate-limits"],"Native model token/second capacities and account monthly spend quota; GPU quotas are excluded.","https://docs.fireworks.ai/serverless/rate-limits"],["siliconflow","SiliconFlow",["account-balance"],"Native current-user balances; retain unknown currency when the API does not report it.","https://docs.siliconflow.com/en/api-reference/userinfo/get-user-info"],["siliconflow-cn","SiliconFlow China",["account-balance"],"Region-specific current-user balances; currency is unknown when the API omits it.","https://docs.siliconflow.cn/"],["novita-ai","Novita",["account-balance"],"Native current-user balances in 1/10000 USD.","https://novita.ai/docs/api-reference/basic-get-user-balance"],["poe","Poe",["account-balance"],"API account point balance; includes plan and add-on points, not session token usage.","https://creator.poe.com/docs/resources/usage-api"],["nano-gpt","NanoGPT",["account-balance","subscription"],"Native USD/Nano balance and documented subscription token windows; null/degraded counters remain unknown.","https://docs.nano-gpt.com/api-reference/endpoint/subscription-usage"],["aihubmix","AIHubMix",["account-balance"],"Current-account balance API needs a Manage Key; inference keys do not grant management access.","https://docs.aihubmix.com/en/api/CliEndpoints/get-self"],["azure","Azure OpenAI",["api-rate-limits"],"Remaining request/token headers for the actual deployment; no ChatGPT subscription or inferred cloud balance.","https://learn.microsoft.com/en-us/azure/ai-foundry/openai/quotas-limits"],["cerebras","Cerebras",["api-rate-limits"],"Only self-describing native counters actually returned for the selected model; console tier examples are not live quota.","https://inference-docs.cerebras.ai/support/rate-limits"],["mistral","Mistral",[],"Documented remaining header lacks a verified unit/window association; no inferred subscription balance.","https://docs.mistral.ai/resources/known-limitations"],["togetherai","Together AI",[],"Dynamic model limits expose retry intervals, not remaining quota; billing UI does not establish a remaining-credit API.","https://docs.together.ai/docs/rate-limits"],["xai","xAI / Grok",[],"Management billing needs separate team credentials; no verified portable remaining API for this inference connection.","https://docs.x.ai/"],["perplexity","Perplexity",[],"No verified remaining-credit API for an inference key. API credits, consumer subscriptions and Computer credits are distinct.","https://www.perplexity.ai/help-center/en/articles/10354847-api-payment-and-billing"],["google","Google Gemini",["configured-limits"],"Native model-matched QuotaFailure responses when provided; cloud quota permissions differ from an inference key.","https://ai.google.dev/gemini-api/docs/rate-limits"],["google-vertex","Google Vertex AI",["configured-limits"],"Native model-matched quota error details; cloud project/region management and dynamic shared quotas are separate.","https://cloud.google.com/vertex-ai/generative-ai/docs/quotas"],["amazon-bedrock","Amazon Bedrock",[],"Service Quotas/CloudWatch require cloud IAM/region/model mapping not exposed by a portable inference connection.","https://docs.aws.amazon.com/bedrock/latest/userguide/quotas.html"],["cloudflare-workers-ai","Cloudflare Workers AI",[],"Account analytics do not prove remaining free allowance; separate account management capability is required.","https://developers.cloudflare.com/workers-ai/platform/limits/"],["huggingface","Hugging Face Inference Providers",[],"Hub request quota is not an inference-model quota or inference-credit balance.","https://huggingface.co/docs/inference-providers/pricing"],["zai","Z.ai / GLM Coding Plan",[],"No verified external quota contract for monitor/dashboard APIs; private endpoints are excluded.","https://docs.z.ai/devpack/overview"],["kimi-for-coding","Kimi Code subscription",[],"Keep separate from Moonshot API balance; an external subscription usage contract/model mapping must be verified.","https://www.kimi.com/code/docs/en/"],["alibaba","Alibaba Cloud / Qwen / DashScope",[],"Cloud account/project billing permissions and model mapping are required; browser OAuth state is not a quota source.","https://www.alibabacloud.com/help/en/model-studio/"],["opencode","OpenCode Zen / Go",[],"Session token/cost statistics are not provider quota; no undocumented billing endpoints.","https://opencode.ai/docs/zen/"],["cursor","Cursor",[],"Consumer usage needs a supported external API; no cookie or credential-file integrations.","https://docs.cursor.com/"],["windsurf","Windsurf / Codeium",[],"Consumer plan windows need a supported external API; no private account endpoints.","https://docs.windsurf.com/"],["amp","Amp",[],"Product credits need a supported external account API; no cookie or local credential extraction.","https://ampcode.com/manual"],["ollama","Ollama",[],"Local inference has no provider subscription window; cloud products require their own account API.","https://docs.ollama.com/api"],["lmstudio","LM Studio",[],"Local inference has no provider subscription quota to read.","https://lmstudio.ai/docs/developer"],["nvidia","NVIDIA NIM / NGC",[],"Inference access does not identify cloud/trial NGC credit balance or self-hosted resource quota.","https://docs.nvidia.com/nim/"],["cohere","Cohere",[],"No verified native remaining-counter contract for this integration; static organization tier examples are not live quotas.","https://docs.cohere.com/docs/rate-limits"],["ai21","AI21",[],"No verified native remaining-counter contract or subscription balance endpoint for this integration.","https://docs.ai21.com/"],["replicate","Replicate",[],"Prediction cost is not remaining account credit; no inferred balance from execution cost.","https://replicate.com/docs/topics/billing"],["chutes","Chutes",[],"Current-user quota APIs exist, but their public schemas do not establish native units/model allowance semantics yet.","https://chutes.ai/docs/api-reference/users"],["requesty","Requesty",[],"Enterprise management key and key ID are required; dated usage reports alone are not remaining budget.","https://docs.requesty.ai/features/key-management-api"],["baseten","Baseten",[],"No independently verified portable remaining quota API for the configured inference connection.","https://docs.baseten.co/"],["modelscope","ModelScope",[],"No independently verified portable remaining quota API/model mapping for the selected connection.","https://opencode.ai/docs/providers/"],["nebius","Nebius",[],"Cloud billing/management access is separate from a plain inference credential.","https://docs.nebius.com/"],["vultr","Vultr",[],"Cloud management quota/billing permissions are separate from inference access.","https://docs.vultr.com/"],["v0","Vercel v0",[],"Consumer/product credits need their own documented external account API.","https://v0.dev/docs"]]
+var PROVIDER_QUOTA_CAPABILITIES=  rows.map(([id,name,sources,reason,url])=>({id,name,sources,reason,documentation:[url]}))
+var aliases={fireworks:"fireworks-ai",novita:"novita-ai",moonshot:"moonshotai","minimax-coding-plan":"minimax","minimax-coding-plan-cn":"minimax-cn",together:"togetherai","silicon-flow":"siliconflow","github-copilot-enterprise":"github-copilot","google-vertex-anthropic":"google-vertex","z-ai":"zai",zhipuai:"zai",dashscope:"alibaba","alibaba-cn":"alibaba",qwen:"alibaba","opencode-go":"opencode","opencode-zen":"opencode",codeium:"windsurf","azure-cognitive-services":"azure"
+}
+function providerQuotaCapability(id,canonical){const key=aliases[canonical??id]??canonical??id
+const found=PROVIDER_QUOTA_CAPABILITIES.find((entry)=>entry.id===key)
+return found??{id,name:id,sources:[],reason:"No independent quota/balance API or native counter semantics are verified for this provider.",documentation:["https://opencode.ai/docs/providers/"]
+}}
+function providerQuotaCatalog(providers=[]){const entries=new Map(PROVIDER_QUOTA_CAPABILITIES.map((entry)=>[entry.id,entry]))
+for(const provider of providers)
+entries.set(provider.id,{...providerQuotaCapability(provider.id,provider.canonical),id:provider.id,name:provider.name
+})
+return [...entries.values()].sort((a,b)=>a.name.localeCompare(b.name))
+}
+import {createHash} from "crypto"
+import {mkdtemp,rm} from "fs/promises"
+import {tmpdir} from "os"
+import {join} from "path"
+function object(value){return value&&typeof value==="object"&&!Array.isArray(value)?value:{}}
+function number(value){if(typeof value==="number"&&Number.isFinite(value))
+return value
+return typeof value==="string"&&/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value)&&Number.isFinite(Number(value))?Number(value):undefined
+}
+function balance(id,label,value,unit,scope="account"){if(number(value)===undefined)
+return []
+return [{id,label,amount:String(value),...unit&&{unit},scope}]
+}
+function scaledAmount(value,digits,multiplier=1n){const numeric=typeof value==="number"&&Number.isSafeInteger(value)?String(value):""
+const text=typeof value==="string"?value:numeric
+if(!/^-?\d+$/.test(text))
+return
+const raw=BigInt(text)*multiplier
+const negative=raw<0n
+const absolute=negative?-raw:raw
+const divisor=10n ** BigInt(digits)
+return `${negative ? "-" : ""}${absolute / divisor}.${String(absolute % divisor).padStart(digits, "0")}`
+}
+function milliseconds(value){const time=number(value)
+return time!==undefined&&time>=100000000000?time / 1000:undefined
+}
+async function withinQuotaSignal(signal,work){signal.throwIfAborted()
+let abort
+try{return await Promise.race([new Promise((_,reject)=>{abort=()=>reject(signal.reason)
+signal.addEventListener("abort",abort,{once:true})
+}),Promise.try(()=>{signal.throwIfAborted()
+return work()
+})])
+} finally{if(abort)
+signal.removeEventListener("abort",abort)
+}}
+class QuotaReadError extends Error{status
+constructor(status,message){super(message)
+this.status=status
+this.name="QuotaReadError"
+}}
+async function readProviderJson(fetcher,url,token,signal,input={}){const combined=AbortSignal.any([signal,AbortSignal.timeout(1e4)])
+const response=await withinQuotaSignal(combined,()=>fetcher(url,{method:input.method??"GET",headers:{...input.apiKeyHeader?{[input.apiKeyHeader]:token}:{Authorization:`Bearer ${token}`},Accept:"application/json",...input.headers
+},signal:combined,redirect:"error"
+}))
+if(!response.ok)
+throw new QuotaReadError(response.status,"Provider quota read was rejected")
+return readQuotaResponseBody(response,combined)
+}
+async function readQuotaResponseBody(response,signal=AbortSignal.timeout(1e4)){const reader=response.body?.getReader()
+const decoder=new TextDecoder
+let body=""
+let bytes=0
+if(reader){try{while(true){const next=await withinQuotaSignal(signal,()=>reader.read())
+if(next.done)
+break
+bytes += next.value.byteLength
+if(bytes>1e6)
+throw new QuotaReadError(502,"Provider quota response is too large")
+body += decoder.decode(next.value,{stream:true})
+}
+body += decoder.decode()
+} finally{reader.cancel().catch(()=>{})
+reader.releaseLock()
+}}
+try{return object(JSON.parse(body))
+} catch{throw new QuotaReadError(502,"Provider quota response is invalid")
+}}
+function createCopilotRuntime(load,timeoutMs){let active
+let disposed=false
+async function cleanup(runtime){const client=runtime.client
+const directory=runtime.directory
+runtime.client=undefined
+runtime.directory=undefined
+await withinQuotaSignal(AbortSignal.timeout(timeoutMs),async ()=>client?.forceStop()).catch(()=>{})
+if(directory)
+await rm(directory,{recursive:true,force:true}).catch(()=>{})
+}
+function discard(runtime){if(active===runtime)
+active=undefined
+runtime.controller.abort(new QuotaReadError(503,"Copilot quota runtime stopped"))
+return cleanup(runtime)
+}
+async function start(runtime){const signal=AbortSignal.any([runtime.controller.signal,AbortSignal.timeout(timeoutMs)])
+try{return await withinQuotaSignal(signal,async ()=>{const sdk=await load()
+signal.throwIfAborted()
+const directory=await mkdtemp(join(tmpdir(),"navigator-copilot-quotas-"))
+runtime.directory=directory
+if(signal.aborted){await cleanup(runtime)
+signal.throwIfAborted()
+}
+const client=new sdk.CopilotClient({mode:"empty",baseDirectory:directory,useLoggedInUser:false,logLevel:"none",enableRemoteSessions:false
+})
+runtime.client=client
+try{await client.start()
+} finally{if(signal.aborted){runtime.client=client
+runtime.directory=directory
+await cleanup(runtime)
+}}
+signal.throwIfAborted()
+return client
+})
+} catch{await discard(runtime)
+throw new QuotaReadError(503,"The official Copilot SDK quota runtime is unavailable")
+}}
+return{async use(signal,work){signal.throwIfAborted()
+if(disposed)
+throw new QuotaReadError(503,"Copilot quota reader disposed")
+const runtime=active ??={controller:new AbortController}
+const combined=AbortSignal.any([signal,runtime.controller.signal,AbortSignal.timeout(timeoutMs)])
+runtime.startup ??= start(runtime)
+try{return await withinQuotaSignal(combined,async ()=>{const client=await runtime.startup
+combined.throwIfAborted()
+return work(client)
+})
+} catch(error){discard(runtime)
+throw error
+}},async dispose(){disposed=true
+if(active)
+await discard(active)
+}}}
+function createCopilotQuotaReader(load=()=>import("@github/copilot-sdk"),timeoutMs=1e4){const runtime=createCopilotRuntime(load,timeoutMs)
+return{async read(input){const [catalog,quota]=await runtime.use(input.signal,(sdk)=>Promise.all([sdk.rpc.models.list({gitHubToken:input.token}),sdk.rpc.account.getQuota({gitHubToken:input.token})]))
+const selected=catalog.models.find((model)=>model.id===input.apiModelID)
+const premium=quota.quotaSnapshots.premium_interactions
+const base={model:input.model,providerId:input.model.providerID,providerName:input.provider.name,fetchedAt:Date.now(),windows:[]
+}
+input.signal.throwIfAborted()
+if(!selected||!selected.billing||!selected.billing.tokenPrices&&(selected.billing.multiplier??0)<=0)
+return{...base,availability:"unsupported",message:"Copilot did not associate the selected model with a premium billing allowance."
+}
+if(!premium)
+return{...base,availability:"unavailable",message:"Copilot did not report a premium allowance; missing details are not zero."
+}
+if(premium.isUnlimitedEntitlement)
+return{...base,availability:"ready",message:"Copilot reports an unlimited premium entitlement for this account."
+}
+const reset=premium.resetDate?Date.parse(premium.resetDate) / 1000:undefined
+if(!Number.isFinite(premium.remainingPercentage))
+return{...base,availability:"unavailable",message:"Copilot quota percentage is unavailable."}
+return{...base,availability:"ready",windows:[{id:"copilot-premium",label:"Premium allowance",modelID:input.model.modelID,kind:"subscription",unit:"%",used:100-premium.remainingPercentage,remaining:premium.remainingPercentage,...reset!==undefined&&Number.isFinite(reset)&&{resetsAt:reset}}]
+}},dispose:runtime.dispose
+}}
+function connectionKey(connection){return connection.type==="credential"?`credential:${connection.id}`:`env:${connection.name}`
+}
+function nativeBaseURL(provider){return typeof provider.settings?.baseURL==="string"?provider.settings.baseURL:undefined
+}
+function matchingOrigin(provider,origins){const configured=nativeBaseURL(provider)
+if(!configured)
+return true
+try{return origins.includes(new URL(configured).origin)
+} catch{return false
+}}
+async function readFireworksQuota(input){if(!matchingOrigin(input.provider,["https://api.fireworks.ai"]))
+return
+const read=(url)=>readProviderJson(input.fetcher,url,input.token,input.signal)
+const accounts=await read("https://api.fireworks.ai/v1/accounts?pageSize=200&readMask=name,displayName")
+const candidates=Array.isArray(accounts.accounts)?accounts.accounts.map((entry)=>object(entry)):[]
+const requested=input.credential.metadata?.accountID
+const selected=typeof requested==="string"?candidates.filter((entry)=>entry.name===requested||entry.name===`accounts/${requested}`):candidates
+const base={model:input.model,providerId:input.model.providerID,providerName:input.provider.name,fetchedAt:Date.now(),windows:[]
+}
+if(selected.length!==1||requested===undefined&&(accounts.nextPageToken||number(accounts.totalSize)>1))
+return{...base,availability:"unavailable",message:"Fireworks billing account is ambiguous; it is never inferred from a model owner."
+}
+const name=typeof selected[0].name==="string"?selected[0].name:""
+if(!/^accounts\/[\w-]+$/.test(name))
+return{...base,availability:"unavailable",message:"Fireworks did not report an account resource name."}
+let page
+for(let index=0;index<10; index++){const url=new URL(`https://api.fireworks.ai/v1/${name}/quotas`)
+url.searchParams.set("pageSize","200")
+if(page)
+url.searchParams.set("pageToken",page)
+const body=await read(url.href)
+const quotas=Array.isArray(body.quotas)?body.quotas:[]
+for(const raw of quotas){const quota=object(raw)
+const total=number(quota.value)
+const used=number(quota.usage)
+if(quota.name===`${name}/quotas/monthly-spend-usd`&&total!==undefined)
+base.windows.push({id:"fireworks-monthly-spend",label:"Account monthly spend cap",modelID:input.model.modelID,limitID:quota.name,kind:"configured_limit",unit:"USD",total,...used!==undefined&&{used,remaining:total-used}})
+}
+page=typeof body.nextPageToken==="string"&&body.nextPageToken?body.nextPageToken:undefined
+if(!page)
+break
+}
+return{...base,accountId:name,availability:base.windows.length>0?"ready":"unavailable",message:"Account-wide spend quota. GPU and unrelated deployment quotas are excluded."
+}}
+function googleQuotaFailureWindows(body,modelID,apiModelID){const details=object(body.error).details
+return(Array.isArray(details)?details:[]).flatMap((raw)=>{const detail=object(raw)
+if(detail["@type"]!=="type.googleapis.com/google.rpc.QuotaFailure")
+return []
+return(Array.isArray(detail.violations)?detail.violations:[]).flatMap((rawViolation)=>{const violation=object(rawViolation)
+const dimensions=object(violation.quotaDimensions)
+const value=number(violation.quotaValue)
+const id=typeof violation.quotaId==="string"?violation.quotaId:""
+const metric=typeof violation.quotaMetric==="string"?violation.quotaMetric:""
+const selected=dimensions.model??dimensions.base_model
+if(selected!==apiModelID||value===undefined)
+return []
+const requestUnit=metric.includes("requests")?"requests":undefined
+const unit=metric.includes("tokens")?"tokens":requestUnit
+if(!unit)
+return []
+return [{id:`google-${id || metric}`,label:id||metric,modelID,limitID:id,kind:"configured_limit",unit,total:value
+}]
+})
+})
+}
+function reset(value,now){if(!value||value.length>128)
+return
+if(value.includes("T")){const time=Date.parse(value)
+return Number.isFinite(time)?time / 1000:undefined
+}
+const parts=[...value.matchAll(/(\d+(?:\.\d+)?)(ms|[dhms])/g)]
+if(parts.length===0||parts.map((part)=>part[0]).join("")!==value)
+return
+const units={d:86400,h:3600,m:60,s:1,ms:0.001}
+return now / 1000 + parts.reduce((seconds,part)=>seconds + Number(part[1])*units[part[2]],0)
+}
+function counterWindow(modelID,headers,now,prefix,suffix,label,unit,durationMinutes){const total=number(headers.get(`${prefix}limit-${suffix}`))
+const remaining=number(headers.get(`${prefix}remaining-${suffix}`))
+if(total===undefined&&remaining===undefined||total!==undefined&&total<0||remaining!==undefined&&remaining<0)
+return []
+const resetsAt=reset(headers.get(`${prefix}reset-${suffix}`),now)
+return [{id:`${prefix}${suffix}`,label,modelID,unit,kind:"rate_limit",...total!==undefined&&{total},...remaining!==undefined&&{remaining},...total!==undefined&&remaining!==undefined&&{used:total-remaining},...durationMinutes!==undefined&&{durationMinutes},...resetsAt!==undefined&&{resetsAt}}]
+}
+function nativeHeaderWindows(providerID,modelID,headers,now=Date.now()){const windows=[]
+const add=(prefix,suffix,label,unit,durationMinutes)=>{windows.push(...counterWindow(modelID,headers,now,prefix,suffix,label,unit,durationMinutes))
+}
+const genericFields=["openai","groq","azure"].includes(providerID)?["requests","tokens","project-tokens"]:[]
+const groqPeriods={requests:1440,tokens:1,"project-tokens":1}
+for(const field of genericFields){add("x-ratelimit-",field,field.replaceAll("-"," "),field==="requests"?"requests":"tokens",providerID==="groq"?groqPeriods[field]:undefined)
+}
+const periodDurations={minute:1,hour:60,day:1440}
+const periods=providerID==="cerebras"?["minute","hour","day"]:[]
+for(const period of periods){for(const field of ["requests","req","tokens"])
+add("x-ratelimit-",`${field}-${period}`,`${field === "req" ? "requests" : field} / ${period}`,field==="tokens"?"tokens":"requests",periodDurations[period])
+}
+const anthropicFields=providerID==="anthropic"?["requests","tokens","input-tokens","output-tokens"]:[]
+const priorityFields=providerID==="anthropic"?["input-tokens","output-tokens"]:[]
+for(const field of anthropicFields)
+add("anthropic-ratelimit-",field,field.replaceAll("-"," "),field==="requests"?"requests":"tokens",1)
+for(const field of priorityFields)
+add("anthropic-priority-",field,`Priority ${field.replaceAll("-", " ")}`,"tokens",1)
+if(["fireworks-ai","fireworks"].includes(providerID)){for(const [field,label] of [["prompt","Total prompt throughput"],["cache-adjusted-prompt","Uncached prompt throughput"],["generated","Output throughput"]]){const total=number(headers.get(`x-ratelimit-limit-tokens-${field}`))
+if(total!==undefined&&total>=0)
+windows.push({id:`fireworks-${field}`,label,modelID,total,unit:"tokens/s",kind:"configured_limit"})
+}}
+return windows
+}
+function balanceSnapshot(model,providerName,values,fetchedAt=Date.now(),accountId){return{model,providerId:model.providerID,providerName,fetchedAt,windows:[],balances:values,...accountId&&{accountId},availability:values.length>0?"ready":"unavailable",...values.length===0&&{message:"The provider did not report an available balance; it is not assumed to be zero."
+}}}
+function deepSeekBalances(body){return(Array.isArray(body.balance_infos)?body.balance_infos:[]).flatMap((raw,index)=>{const row=object(raw)
+const unit=typeof row.currency==="string"?row.currency:undefined
+return [...balance(`available-${index}`,"Available balance",row.total_balance,unit),...balance(`granted-${index}`,"Granted balance",row.granted_balance,unit),...balance(`topup-${index}`,"Top-up balance",row.topped_up_balance,unit)]
+})
+}
+function moonshotBalances(body,currency){const data=object(body.data)
+return body.code===0&&body.status!==false?[...balance("available","Available balance",data.available_balance,currency),...balance("voucher","Voucher balance",data.voucher_balance,currency),...balance("cash","Cash balance",data.cash_balance,currency)]:[]
+}
+function siliconFlowBalances(body){const data=object(body.data)
+return body.status===false?[]:[...balance("available","Available balance",data.totalBalance),...balance("charged","Charged balance",data.chargeBalance),...balance("granted","Granted balance",data.balance)]
+}
+function novitaBalances(body){return [["availableBalance","Available balance"],["cashBalance","Cash balance"],["creditLimit","Credit limit"],["pendingCharges","Pending charges"],["outstandingInvoices","Outstanding invoices"]].flatMap(([field,label])=>balance(field,label,scaledAmount(body[field],4),"USD"))
+}
+function miniMaxBalances(body){const status=number(object(body.base_resp).status_code)
+if(status!==undefined&&status!==0)
+return []
+return [["available_amount","Available balance"],["cash_balance","Cash balance"],["voucher_balance","Voucher balance"],["credit_balance","Credit balance"],["owed_amount","Owed amount"]].flatMap(([field,label])=>balance(field,label,body[field]))
+}
+function poeBalances(body){return balance("points","Available plan and add-on points",body.current_point_balance,"points")
+}
+function nanoBalances(body){return [...balance("usd","Account balance",body.usd_balance,"USD"),...balance("nano","Balance in Nano",body.nano_balance,"NANO")]
+}
+function aiHubMixBalances(body){return body.success===true?balance("available","Available balance",scaledAmount(object(body.data).quota,6,2n),"USD"):[]
+}
+function openRouterBudget(body){const data=object(body.data)
+const remaining=number(data.limit_remaining)
+return data.limit===null?[{id:"key-budget",label:"Key spending budget",scope:"key",unlimited:true,unit:"USD"}]:balance("key-budget","Remaining key spending budget",remaining,"USD","key")
+}
+function miniMaxWindows(body,modelID,apiModelID){const responseStatus=number(object(body.base_resp).status_code)
+if(responseStatus!==undefined&&responseStatus!==0)
+return []
+return(Array.isArray(body.model_remains)?body.model_remains:[]).flatMap((raw)=>{const row=object(raw)
+if(row.model_name!==apiModelID)
+return []
+return ["interval","weekly"].flatMap((period)=>{const total=number(row[`current_${period}_total_count`])
+const remainingPercent=number(row[`current_${period}_remaining_percent`])
+const status=number(row[`current_${period}_status`])
+if(total===undefined||total<=0||status===3)
+return []
+const reset=milliseconds(row[period==="weekly"?"weekly_end_time":"end_time"])
+return [{id:`minimax-${period}`,label:period==="weekly"?"Weekly Token Plan":"Token Plan window",modelID,kind:remainingPercent===undefined?"configured_limit":"subscription",unit:remainingPercent===undefined?"usage units":"%",...remainingPercent===undefined?{total}:{used:100-remainingPercent,remaining:remainingPercent},...reset!==undefined&&{resetsAt:reset}}]
+})
+})
+}
+function nanoWindows(body,modelID){if(body.active!==true)
+return []
+const limits=object(body.limits)
+return ["dailyInputTokens","weeklyInputTokens"].flatMap((period)=>{const row=object(body[period])
+const total=number(limits[period])
+const used=number(row.used)
+const remaining=number(row.remaining)
+if(row.degraded===true||total===undefined||used===undefined&&remaining===undefined)
+return []
+const resetsAt=milliseconds(row.resetAt)
+return [{id:`nanogpt-${period}`,label:period==="dailyInputTokens"?"Daily subscription input tokens":"Weekly subscription input tokens",modelID,kind:"subscription",unit:"tokens",total,...used!==undefined&&{used},...remaining!==undefined&&{remaining},...resetsAt!==undefined&&{resetsAt}}]
+})
+}
+function anthropicConfiguredWindows(body,modelID,apiModelID){return(Array.isArray(body.data)?body.data:[]).flatMap((raw)=>{const row=object(raw)
+if(object(row.group).type!=="model_group"||!Array.isArray(row.models)||!row.models.includes(apiModelID))
+return []
+return(Array.isArray(row.limits)?row.limits:[]).flatMap((rawLimit)=>{const limit=object(rawLimit)
+const value=number(limit.value)
+const type=typeof limit.type==="string"?limit.type:""
+const match=/^(requests|input_tokens|output_tokens|tokens)_per_(minute|day)$/.exec(type)
+if(value===undefined||!match)
+return []
+return [{id:`anthropic-${row.id}-${type}`,label:type.replaceAll("_"," "),modelID,limitID:typeof row.id==="string"?row.id:undefined,kind:"configured_limit",unit:match[1].includes("tokens")?"tokens":"requests",durationMinutes:match[2]==="day"?1440:1,total:value
+}]
+})
+})
+}
+async function readAnthropicQuota(input){const options={headers:{"anthropic-version":"2023-06-01"},...input.credential.type==="key"&&{apiKeyHeader:"x-api-key"}}
+const windows=[]
+let page
+for(let index=0;index<10; index++){const url=new URL("https://api.anthropic.com/v1/organizations/rate_limits")
+url.searchParams.set("model",input.apiModelID)
+if(page)
+url.searchParams.set("page",page)
+const body=await readProviderJson(input.fetcher,url.href,input.token,input.signal,options)
+windows.push(...anthropicConfiguredWindows(body,input.model.modelID,input.apiModelID))
+page=typeof body.next_page==="string"&&body.next_page?body.next_page:undefined
+if(!page)
+break
+}
+return{...balanceSnapshot(input.model,input.provider.name,[]),windows,availability:windows.length>0?"ready":"unsupported",message:windows.length>0?"Configured rate limits; remaining capacity is not reported by this API.":"No explicit rate-limit group was reported for the selected model."
+}}
+var origins={deepseek:["https://api.deepseek.com"],moonshotai:["https://api.moonshot.ai"],"moonshotai-cn":["https://api.moonshot.cn"],siliconflow:["https://api.siliconflow.com"],"siliconflow-cn":["https://api.siliconflow.cn"],"novita-ai":["https://api.novita.ai"],poe:["https://api.poe.com"],aihubmix:["https://aihubmix.com","https://api.aihubmix.com"],minimax:["https://api.minimax.io","https://www.minimax.io"],"minimax-cn":["https://api.minimaxi.com","https://www.minimaxi.com"],"nano-gpt":["https://nano-gpt.com","https://api.nano-gpt.com"],anthropic:["https://api.anthropic.com"]
+}
+async function readNativeRest(input){const{canonical,token,signal,fetcher,model,provider,apiModelID}=input
+const allowed=origins[canonical]
+if(!allowed||!matchingOrigin(provider,allowed))
+return
+const read=(url,options)=>readProviderJson(fetcher,url,token,signal,options)
+const make=(values,accountId)=>balanceSnapshot(model,provider.name,values,Date.now(),accountId)
+switch(canonical){case "deepseek":{return make(deepSeekBalances(await read("https://api.deepseek.com/user/balance")))
+}
+case "moonshotai":{return make(moonshotBalances(await read("https://api.moonshot.ai/v1/users/me/balance"),"USD"))
+}
+case "moonshotai-cn":{return make(moonshotBalances(await read("https://api.moonshot.cn/v1/users/me/balance"),"CNY"))
+}
+case "siliconflow":case "siliconflow-cn":{const body=await read(`${allowed[0]}/v1/user/info`)
+const id=object(body.data).id
+return make(siliconFlowBalances(body),typeof id==="string"?id:undefined)
+}
+case "novita-ai":{return make(novitaBalances(await read("https://api.novita.ai/openapi/v1/billing/balance/detail")))
+}
+case "poe":{return make(poeBalances(await read("https://api.poe.com/usage/current_balance")))
+}
+case "aihubmix":{return make(aiHubMixBalances(await read("https://aihubmix.com/api/user/self")))
+}
+case "minimax":case "minimax-cn":{const base=allowed[0]
+if(input.credential.type==="key"&&token.startsWith("sk-api-"))
+return make(miniMaxBalances(await read(`${base}/account/query_balance`)))
+const body=await read(`${base}/v1/token_plan/remains`)
+const windows=miniMaxWindows(body,model.modelID,apiModelID)
+return{...make([]),windows,availability:windows.length>0?"ready":"unavailable",message:windows.length>0?undefined:"No finite, model-associated Token Plan allowance was reported. Missing or ambiguous counts are not treated as remaining quota."
+}}
+case "nano-gpt":{const configured=nativeBaseURL(provider)
+const base=configured?new URL(configured).origin:allowed[0]
+const balances=nanoBalances(await read(`${base}/api/check-balance`,{method:"POST",apiKeyHeader:"x-api-key"}))
+let subscription
+try{subscription=await Promise.all([read(`${base}/api/subscription/v1/usage`),read(`${base}/api/subscription/v1/models`)])
+} catch(error){if(signal.aborted||balances.length===0)
+throw error
+return{...make(balances),message:"Account balance is available; subscription counters could not be read."}}
+const [usage,models]=subscription
+const covered=Array.isArray(models.data)&&models.data.some((entry)=>object(entry).id===apiModelID)
+const windows=covered?nanoWindows(usage,model.modelID):[]
+return{...make(balances),windows,...windows.length>0&&{availability:"ready"},...windows.length===0&&{message:"Subscription windows are shown only for provider-listed subscription models with non-degraded counters."
+}}}
+case "anthropic":{return readAnthropicQuota(input)
+}}
+return
+}
+function openRouterFreeWindow(body,modelID,apiModelID){if(!apiModelID.endsWith(":free"))
+return []
+const data=object(object(body.data).free_model_daily_requests)
+const total=number(data.limit)
+const remaining=number(data.remaining)
+const used=number(data.used)
+return total!==undefined&&(used!==undefined||remaining!==undefined)?[{id:"openrouter-free-daily",label:"Free-model daily requests",modelID,unit:"requests",durationMinutes:1440,kind:"rate_limit",total,...used!==undefined&&{used},...remaining!==undefined&&{remaining}}]:[]
+}
+function managementCredits(body){const data=object(body.data)
+const total=number(data.total_credits)
+const used=number(data.total_usage)
+return total!==undefined&&used!==undefined?balance("account-credits","Remaining account credits",total-used,"USD"):[]
+}
+async function readOpenRouterQuota(input){if(!matchingOrigin(input.provider,["https://openrouter.ai"]))
+return
+const body=await readProviderJson(input.fetcher,"https://openrouter.ai/api/v1/key",input.token,input.signal)
+const data=object(body.data)
+const balances=openRouterBudget(body)
+if(data.is_management_key===true)
+balances.push(...managementCredits(await readProviderJson(input.fetcher,"https://openrouter.ai/api/v1/credits",input.token,input.signal)))
+const windows=openRouterFreeWindow(body,input.model.modelID,input.apiModelID)
+const id=typeof data.organization_id==="string"?data.organization_id:undefined
+return{...balanceSnapshot(input.model,input.provider.name,balances,Date.now(),id),windows,...windows.length>0&&{availability:"ready"},message:data.is_management_key===true?undefined:"Key budget, not account balance. Reading account credits requires a management key."
+}}
+async function nativeQuotaContext(host,model,signal,fetcher){const [provider,catalog]=await Promise.all([host.provider.get({providerID:model.providerID}),host.model.list()])
+const selected=catalog.data.find((entry)=>entry.providerID===model.providerID&&entry.id===model.modelID&&entry.enabled)
+if(!selected||!provider.data.integrationID||provider.data.activation==="disabled")
+return
+const connection=await host.integration.connection.active(provider.data.integrationID)
+if(!connection)
+return
+const credential=await host.integration.connection.resolve(connection)
+const token=credential?.type==="oauth"?credential.access:credential?.key
+if(!credential||!token)
+return
+signal.throwIfAborted()
+return{model,apiModelID:selected.modelID,provider:provider.data,canonical:providerQuotaCapability(provider.data.id,provider.data.canonical).id,connection,connectionID:connectionKey(connection),credential,token,signal,fetcher
+}}
+async function sameNativeConnection(host,input){const current=input.provider.integrationID&&await host.integration.connection.active(input.provider.integrationID)
+if(!current||connectionKey(current)!==input.connectionID)
+return false
+const credential=await host.integration.connection.resolve(current)
+const token=credential?.type==="oauth"?credential.access:credential?.key
+return token===input.token
+}
+function requestUsesCredential(request,input){const url=new URL(request.url)
+const origins={openai:"https://api.openai.com",anthropic:"https://api.anthropic.com",groq:"https://api.groq.com",cerebras:"https://api.cerebras.ai","fireworks-ai":"https://api.fireworks.ai",google:"https://generativelanguage.googleapis.com"
+}
+const cloudOrigin=url.protocol==="https:"&&(input.canonical==="azure"&&url.hostname.endsWith(".openai.azure.com")||input.canonical==="google-vertex"&&url.hostname.endsWith(".aiplatform.googleapis.com"))
+if(!cloudOrigin&&url.origin!==origins[input.canonical])
+return false
+const authorization=request.headers.get("authorization")
+if(authorization===`Bearer ${input.token}`||authorization===`bearer ${input.token}`)
+return true
+if(["x-api-key","api-key","x-goog-api-key"].some((header)=>request.headers.get(header)===input.token))
+return true
+return url.hostname==="generativelanguage.googleapis.com"&&url.searchParams.get("key")===input.token
+}
+function key2(input){return JSON.stringify([input.model.providerID,input.model.modelID,input.model.variant,input.connectionID,createHash("sha256").update(input.token).digest("hex")])
+}
+function modelForEvent(event){return{providerID:event.model.providerID,modelID:event.model.id,sessionID:event.sessionID}}
+function rejectedRead(model,error,input){const status=error instanceof QuotaReadError?error.status:undefined
+const states={429:"rate_limited",401:"unauthenticated",403:"permission_required",404:"unsupported"
+}
+return{model,providerId:model.providerID,providerName:input?.provider.name??providerQuotaCapability(model.providerID).name,fetchedAt:Date.now(),windows:[],...input&&{connectionID:input.connectionID},availability:status===undefined?"unavailable":states[status]??"unavailable",message:status===403?"The active credential does not have the provider quota/billing permission required by this API.":"The documented provider quota source is unavailable. No credentials or raw provider error details are exposed."
+}}
+function createNativeQuotaService(host,lifecycle,fetcher=fetch,copilot=createCopilotQuotaReader()){const observed=new Map
+const cached=new Map
+const captured=new WeakMap
+let generation=0
+const base=(model)=>({model,providerId:model.providerID,providerName:providerQuotaCapability(model.providerID).name,fetchedAt:Date.now(),windows:[],availability:"unavailable"
+})
+async function rest(input){if(input.canonical==="openrouter")
+return readOpenRouterQuota(input)
+if(input.canonical==="fireworks-ai")
+return readFireworksQuota(input)
+if(input.canonical==="github-copilot")
+return copilot.read(input)
+return readNativeRest(input)
+}
+async function currentResult(input,force){const identity=key2(input)
+const headers=observed.get(identity)
+const existing=cached.get(identity)
+let result=!force&&existing&&Date.now()-existing.fetchedAt<30000?existing:undefined
+if(headers&&input.canonical==="anthropic")
+result=headers
+else if(!result){try{result=await rest(input)
+} catch(error){if(!headers)
+throw error
+result=headers
+}}
+return{identity,headers,result:result??headers}}
+return{invalidate(){generation++
+cached.clear()
+observed.clear()
+},async request(event){if(lifecycle.aborted||event.kind!=="primary"||!/(?:\/chat\/completions|\/messages|\/responses|:generateContent|:streamGenerateContent)$/.test(new URL(event.request.url).pathname))
+return
+const epoch=generation
+const observation=AbortSignal.any([lifecycle,AbortSignal.timeout(1000)])
+try{const input=await withinQuotaSignal(observation,()=>nativeQuotaContext(host,modelForEvent(event),observation,fetcher))
+if(input&&epoch===generation&&requestUsesCredential(event.request,input)&&await withinQuotaSignal(observation,()=>sameNativeConnection(host,input)))
+captured.set(event.request,{key:key2(input),generation:epoch})
+} catch{}},async response(event){const request=captured.get(event.request)
+if(!request||request.generation!==generation||lifecycle.aborted)
+return false
+const observation=AbortSignal.any([lifecycle,AbortSignal.timeout(1000)])
+try{const input=await withinQuotaSignal(observation,()=>nativeQuotaContext(host,modelForEvent(event),observation,fetcher))
+if(!input||key2(input)!==request.key||!await withinQuotaSignal(observation,()=>sameNativeConnection(host,input)))
+return false
+let windows=nativeHeaderWindows(input.canonical,input.model.modelID,event.response.headers)
+if(windows.length===0&&event.response.status===429&&["google","google-vertex"].includes(input.canonical)&&event.response.headers.get("content-type")?.includes("json"))
+windows=googleQuotaFailureWindows(await readQuotaResponseBody(event.response.clone(),observation),input.model.modelID,input.apiModelID)
+if(windows.length===0||request.generation!==generation)
+return false
+observed.set(request.key,{...base(input.model),providerName:input.provider.name,connectionID:input.connectionID,availability:"ready",windows,message:"Provider-native API limits observed from this model response; no extra inference request was made."
+})
+return true
+} catch{return false
+}},async read(target,signal){const model={providerID:target.providerID,modelID:target.modelID,sessionID:target.sessionID,...target.variant&&{variant:target.variant}}
+const epoch=generation
+const combined=AbortSignal.any([lifecycle,signal,AbortSignal.timeout(15000)])
+let input
+try{input=await withinQuotaSignal(combined,()=>nativeQuotaContext(host,model,combined,fetcher))
+if(!input)
+return{...base(model),availability:"unauthenticated",message:"No eligible active provider connection or selected model was reported by OpenCode."
+}
+if(target.connectionID&&target.connectionID!==input.connectionID)
+return{...base(model),availability:"unauthenticated",message:"The OpenCode connection changed; the old account is not queried."
+}
+const current=input
+const{identity,headers,result}=await withinQuotaSignal(combined,()=>currentResult(current,target.force))
+combined.throwIfAborted()
+if(epoch!==generation||!await withinQuotaSignal(combined,()=>sameNativeConnection(host,current)))
+return{...base(model),availability:"unauthenticated",message:"The provider account changed during the quota read."
+}
+if(!result){const capability=providerQuotaCapability(input.canonical)
+return{...base(model),providerName:input.provider.name,connectionID:input.connectionID,availability:capability.sources.length>0?"waiting":"unsupported",message:capability.reason
+}}
+const freshHeaders=headers&&Date.now()-headers.fetchedAt<=120000
+const merged={...result,model,connectionID:input.connectionID,windows:[...result.windows,...freshHeaders&&headers!==result?headers.windows:[]],...headers===result&&Date.now()-result.fetchedAt>120000&&{availability:"stale"}}
+if(headers!==result)
+cached.set(identity,{...result,model,connectionID:input.connectionID})
+return merged
+} catch(error){if(signal.aborted||lifecycle.aborted)
+throw error
+return rejectedRead(model,error,input)
+}},async dispose(){cached.clear()
+observed.clear()
+await copilot.dispose()
+}}}
+async function setupProviderQuotaServer(host){const lifecycle=new AbortController
+const service=createNativeQuotaService(host,lifecycle.signal)
+const rpc=await host.rpc.register(NavigatorQuotaRpc,{read:async (input,context)=>normalizeProviderQuota(await service.read(input,context.signal)),capabilities:async ()=>{const providers=await host.provider.list()
+return providerQuotaCatalog(providers.data)
+}})
+const request=await host.session.hook("http.request",(event)=>service.request(event))
+const response=await host.session.hook("http.response",async (event)=>{if(await service.response(event))
+await rpc.events.emit("updated",{providerID:event.model.providerID,modelID:event.model.id}).catch(()=>{})
+});
+(async ()=>{const events=host.event.subscribe({signal:lifecycle.signal})
+for await (const event of events){if(["credential.updated","credential.switched","integration.updated","provider.updated"].includes(event.type))
+service.invalidate()
+}})().catch(()=>{})
+return async ()=>{lifecycle.abort()
+await request.dispose()
+await response.dispose()
+await rpc.dispose()
+await service.dispose()
+}}
 var input={type:"object",properties:{todos:NavigatorTodoRpc.methods.replace.input.properties.todos
 },required:["todos"],additionalProperties:false
 }
@@ -64,7 +650,9 @@ const context=await host.session.hook("context",async (event)=>{const state=awai
 if(state.guidance)
 event.system.push({type:"text",text:todoGuidance(state)})
 })
-return async ()=>{await context.dispose()
+const quotaCleanup=typeof host.integration?.connection?.active==="function"&&typeof host.provider?.get==="function"?await setupProviderQuotaServer(host):undefined
+return async ()=>{await quotaCleanup?.()
+await context.dispose()
 await tools.dispose()
 await rpc.dispose()
 }}})