opencode-navigator 0.25.0 → 0.27.0

package/dist/provider-limits.js

@@ -1,5 +1,5 @@
 import {PLUGIN_ID
-} from "./chunk-bv0nm1tj.js";
+} from "./chunk-dm1y8x49.js";
 function createCodexAppServerClient(input){const command=input.command??["codex","app-server","--stdio"]
 const timeoutMs=input.timeoutMs??1e4
 const pending=new Map
@@ -14,8 +14,9 @@ pending.delete(id)
 }}
 function write(message){if(!child?.stdin||typeof child.stdin==="number")
 throw new Error("Codex app-server is unavailable")
-child.stdin.write(`${JSON.stringify(message)}
-`)
+Promise.resolve(child.stdin.write(`${JSON.stringify(message)}
+`)).catch((error)=>{failAll(error instanceof Error?error:new Error("Codex app-server write failed"))
+})
 }
 function accept(line){let message
 try{message=JSON.parse(line)
@@ -133,6 +134,29 @@ 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 CHATGPT_METHODS=new Set(["chatgpt-browser","chatgpt-headless"])
+function providerAccountIdentity(provider,credentials){if(!provider.integrationID||provider.activation==="disabled")
+return{status:"unsupported"}
+const active=credentials.filter((entry)=>entry.integrationID===provider.integrationID&&entry.active)
+if(active.length!==1)
+return{status:"unavailable"}
+const credential=active[0]
+const id=`credential:${credential.id}`
+if(credential.value.type==="external")
+return{status:"unsupported",id}
+const providerID=provider.canonical??provider.id
+if(credential.value.type==="key")
+return{status:"ready",id,method:"api",providerID}
+if(provider.integrationID!=="openai")
+return{status:"ready",id,method:"oauth",providerID}
+if(!credential.value.methodID||!CHATGPT_METHODS.has(credential.value.methodID))
+return{status:"unsupported",id}
+const account=credential.value.metadata?.accountID
+const accountID=typeof account==="string"&&account.trim()?account:undefined
+const header=Object.entries(provider.headers??{}).find(([name])=>name.toLowerCase()==="chatgpt-account-id")?.[1]
+if(accountID&&header&&header!==accountID)
+return{status:"loading"}
+return{status:"ready",id,method:"oauth",providerID,...accountID&&{accountID}}}
 import {createSignal as createSignal2,untrack} from "solid-js"
 import {createSignal} from "solid-js"
 var idle={status:"idle"}
@@ -200,6 +224,7 @@ setStates((values)=>({...values,[target]:{status:"error",error:requestError(caus
 }}
 return{state,start,abort,abortAll}}
 function createProviderLimitsController(adapters,selectedModel,signal,refreshContext){const requests=createRequestState(signal)
+const pending=new Map
 const [snapshots,setSnapshots]=createSignal2({})
 const targetKey=(model)=>JSON.stringify(model)
 let activeKey
@@ -208,6 +233,7 @@ function current(){const model=selectedModel()
 const adapter=model&&adapters.find((candidate)=>candidate.supports(model))
 const key=model?targetKey(model):undefined
 if(activeKey!==key){untrack(requests.abortAll)
+pending.clear()
 targetAbort.abort()
 targetAbort=new AbortController
 activeKey=key
@@ -219,10 +245,13 @@ const{model,adapter}=current()
 if(!model||!adapter)
 return
 const key=targetKey(model)
+const existing=pending.get(key)
+if(existing&&!force)
+return existing
 const request=requests.start(key,"read provider limits",Boolean(snapshots()[key]),force)
 if(!request)
 return
-try{const snapshot=normalizeProviderQuota(await adapter.read(model,request.signal,force))
+const promise=(async ()=>{try{const snapshot=normalizeProviderQuota(await adapter.read(model,request.signal,force))
 if(!request.isCurrent()||targetKey(current().model??model)!==key)
 return
 setSnapshots((value)=>({...value,[key]:snapshot}))
@@ -234,6 +263,11 @@ request.succeed()
 } else
 request.fail(error)
 } finally{request.finish()
+}})()
+pending.set(key,promise)
+try{await promise
+} finally{if(pending.get(key)===promise)
+pending.delete(key)
 }}
 return{current,targetSignal(){current()
 return signal?AbortSignal.any([signal,targetAbort.signal]):targetAbort.signal
@@ -242,6 +276,7 @@ return model&&adapter?snapshots()[targetKey(model)]:undefined
 },state(){const{model,adapter}=current()
 return model&&adapter?requests.state(targetKey(model)):{status:"idle"}},dispose(){targetAbort.abort()
 requests.abortAll()
+pending.clear()
 for(const adapter of adapters)
 adapter.dispose?.()
 }}}
@@ -282,7 +317,9 @@ return [{id:`${id}.${name}`,label:account?`Codex account \xB7 ${name}`:`${limit.
 })
 })
 }
-function createCodexQuotaAdapter(client,validateHost){const adapter={id:"codex",name:"Codex CLI",supports:(model)=>(model.providerID==="openai"||model.hostConnection?.providerID==="openai")&&model.hostConnection?.method!=="api"&&Boolean(model.accountID)&&(!model.hostConnection||model.hostConnection.status==="ready"),...validateHost&&{validateHost},async discoverAccount(signal){const account=await client.request("account/read",{refreshToken:false},signal)
+function supportsCodexQuota(model){return(model.providerID==="openai"||model.hostConnection?.providerID==="openai")&&model.hostConnection?.method!=="api"&&Boolean(model.accountID)&&(!model.hostConnection||model.hostConnection.status==="ready")
+}
+function createCodexQuotaAdapter(client,validateHost){const adapter={id:"codex",name:"Codex CLI",supports:supportsCodexQuota,...validateHost&&{validateHost},async discoverAccount(signal){const account=await client.request("account/read",{refreshToken:false},signal)
 if(account.account?.type!=="chatgpt")
 throw new Error("Sign in to Codex CLI with ChatGPT")
 const usage=await client.request("account/rateLimits/read",{supportsLunaReserve:false,excludeResetCreditDetails:true},signal)
@@ -337,35 +374,53 @@ return adapter
 import {createComponent as _$createComponent} from "@opentui/solid"
 import {createSignal as createSignal3} from "solid-js"
 import {GuardedConfirmation} from "./tui.js"
+var alwaysCurrent=()=>true
+class CodexAccountMismatchError extends Error{constructor(){super("Sign in to Codex CLI with the account selected in OpenCode.")
+this.name="CodexAccountMismatchError"
+}}
+function canLinkCodexAccount(model){return(model.providerID==="openai"||model.hostConnection?.providerID==="openai")&&model.hostConnection?.method!=="api"&&(!model.hostConnection||model.hostConnection.status==="ready")
+}
+function createCodexAccountLinkModel(input){const model=input.selected()
+const key=JSON.stringify(model)
+const current=()=>!input.signal.aborted&&(input.current??alwaysCurrent)()&&JSON.stringify(input.selected())===key
+const validHost=async ()=>Boolean(model&&(!input.adapter.validateHost||await input.adapter.validateHost(model,input.signal)))
+async function discover(){if(!model||!current()||!input.adapter.discoverAccount||!canLinkCodexAccount(model))
+return
+if(!await validHost()||!current())
+return
+const accountID=await input.adapter.discoverAccount(input.signal)
+if(!current())
+return
+if(model.hostConnection?.accountID&&model.hostConnection.accountID!==accountID)
+throw new CodexAccountMismatchError
+return{accountID,model}}
+return{current,discover,async confirm(preview){const latest=await discover()
+if(!latest||!current()||latest.accountID!==preview.accountID)
+return false
+await input.bind(latest.model.providerID,latest.model.hostConnection?.id,latest.accountID)
+return true
+}}}
 function createCodexAccountLink(input){const [busy,setBusy]=createSignal3(false)
 async function link(){const selected=input.model()
 if(busy()||!selected||selected.providerID!=="openai"&&selected.hostConnection?.providerID!=="openai"||!input.adapter.discoverAccount)
 return
 if(selected.hostConnection&&selected.hostConnection.status!=="ready")
 return
-const key=JSON.stringify(selected)
-const current=()=>JSON.stringify(input.model())===key
 const signal=input.api.lifecycle?.signal??new AbortController().signal
-const validHost=async ()=>!input.adapter.validateHost||await input.adapter.validateHost(selected,signal)
-setBusy(true)
-try{if(!await validHost()||!current())
-return
-const accountID=await input.adapter.discoverAccount(signal)
-if(!current())
-return
-if(selected.hostConnection?.accountID&&selected.hostConnection.accountID!==accountID){input.api.ui.toast({variant:"warning",title:"Codex account",message:"Sign in to Codex CLI with the account selected in OpenCode."
+const model=createCodexAccountLinkModel({adapter:input.adapter,selected:input.model,signal,bind:input.preferences.setCodexConnectionBinding
 })
+const current=model.current
+setBusy(true)
+try{const preview=await model.discover()
+if(!preview)
 return
-}
+const{accountID
+}=preview
 async function confirm(){if(busy()||!current())
 return
 setBusy(true)
-try{if(!await validHost()||!current())
-return
-const latest=await input.adapter.discoverAccount(signal)
-if(!current()||latest!==accountID)
-return
-input.preferences.setCodexConnectionBinding(selected.providerID,selected.hostConnection?.id,accountID)
+try{if(await model.confirm({accountID
+}))
 input.dialogs.back()
 } catch{if(current())
 input.api.ui.toast({variant:"warning",title:"Codex account",message:"Account verification failed; try again."
@@ -376,8 +431,8 @@ input.dialogs.open(()=>_$createComponent(GuardedConfirmation,{get api(){return i
 },current,title:"Link Codex CLI account",get message(){return `Use Codex CLI account ${accountID} for ${selected.providerID}${selected.hostConnection?.id ? " connection" : ""} across models? Only confirm matching accounts.`
 },onConfirm:()=>void confirm()
 }))
-} catch{if(current())
-input.api.ui.toast({variant:"warning",title:"Codex account",message:"Install a supported Codex CLI and sign in with ChatGPT, then try again."
+} catch(error){if(current())
+input.api.ui.toast({variant:"warning",title:"Codex account",message:error instanceof CodexAccountMismatchError?error.message:"Install a supported Codex CLI and sign in with ChatGPT, then try again."
 })
 } finally{setBusy(false)
 }}
@@ -479,41 +534,55 @@ import {SelectionMenu,useDialogs} from "./tui.js"
 import {createComponent as _$createComponent2} from "@opentui/solid"
 import {randomUUID} from "crypto"
 import {GuardedConfirmation as GuardedConfirmation2,useDialogState} from "./tui.js"
-function createResetCreditActions(input){const [busy,setBusy]=useDialogState("credit-busy",false)
-const signal=input.controller.targetSignal
-const warn=(message)=>input.api.ui.toast({variant:"warning",title:"Codex reset credit",message
-})
-async function consume(creditID){if(busy()||!input.current()||!input.model.accountID||!input.adapter.consumeResetCredit)
+var resetCreditOutcomeMessage={reset:"Reset applied. Restart or continue your Codex session.",alreadyRedeemed:"This attempt was already redeemed; no second credit was used.",noCredit:"No reset credit is available.",nothingToReset:"There is no eligible usage window to reset."
+};
+function resetAttemptMatches(model,attempt){return attempt.accountID===model.accountID&&attempt.modelID===model.modelID&&attempt.providerID===model.providerID&&(attempt.connectionID===undefined||attempt.connectionID===model.hostConnection?.id)
+}
+function createResetCreditModel(input){async function consume(creditID){if(input.busy()||!input.current()||!input.model.accountID||!input.adapter.consumeResetCredit)
 return
-setBusy(true)
+input.setBusy(true)
 const previous=input.preferences.pendingResetAttempt()
-const attempt=previous??{providerID:input.model.providerID,modelID:input.model.modelID,accountID:input.model.accountID,...creditID&&{creditID
-},idempotencyKey:randomUUID(),createdAt:Date.now(),...input.model.hostConnection?.id&&{connectionID:input.model.hostConnection.id
-}}
-try{if(attempt.accountID!==input.model.accountID||attempt.modelID!==input.model.modelID||attempt.providerID!==input.model.providerID||attempt.connectionID!==undefined&&attempt.connectionID!==input.model.hostConnection?.id){throw new Error("Resolve the earlier attempt on its linked account and model first")
-}
+const attempt=previous??{providerID:input.model.providerID,modelID:input.model.modelID,accountID:input.model.accountID,...creditID&&{creditID},idempotencyKey:input.id(),createdAt:input.now(),...input.model.hostConnection?.id&&{connectionID:input.model.hostConnection.id}}
+try{if(!resetAttemptMatches(input.model,attempt))
+throw new Error("Resolve the earlier attempt on its linked account and model first")
 if(!previous)
 await input.preferences.beginResetAttempt(attempt)
 if(!input.current())
 return
-const outcome=await input.adapter.consumeResetCredit(input.model,{...attempt,uncertain:Boolean(previous)
-},signal())
+const outcome=await input.adapter.consumeResetCredit(input.model,{...attempt,uncertain:Boolean(previous)},input.signal())
 await input.preferences.finishResetAttempt(attempt.idempotencyKey)
-await input.controller.refresh(true)
-input.api.ui.toast({variant:outcome==="reset"||outcome==="alreadyRedeemed"?"success":"info",title:"Codex reset credit",message:{reset:"Reset applied. Restart or continue your Codex session.",alreadyRedeemed:"This attempt was already redeemed; no second credit was used.",noCredit:"No reset credit is available.",nothingToReset:"There is no eligible usage window to reset."
-}[outcome]
+await input.refresh()
+return outcome
+} finally{input.setBusy(false)
+}}
+async function review(creditID){if(input.busy()||!input.current()||!input.adapter.prepareResetCreditConsumption||!input.adapter.consumeResetCredit)
+return
+input.setBusy(true)
+try{const snapshot=await input.adapter.prepareResetCreditConsumption(input.model,creditID,input.signal())
+if(!input.current()||snapshot.accountId!==input.model.accountID)
+return
+return snapshot
+} finally{input.setBusy(false)
+}}
+return{review,consume,busy:input.busy}}
+function createResetCreditActions(input){const [busy,setBusy]=useDialogState("credit-busy",false)
+const signal=input.controller.targetSignal
+const warn=(message)=>input.api.ui.toast({variant:"warning",title:"Codex reset credit",message
+})
+const model=createResetCreditModel({preferences:input.preferences,adapter:input.adapter,model:input.model,current:input.current,signal,busy,setBusy,id:randomUUID,now:Date.now,refresh:()=>input.controller.refresh(true)
+})
+async function consume(creditID){try{const outcome=await model.consume(creditID)
+if(!outcome)
+return
+input.api.ui.toast({variant:outcome==="reset"||outcome==="alreadyRedeemed"?"success":"info",title:"Codex reset credit",message:resetCreditOutcomeMessage[outcome]
 })
 if(input.current())
 input.dialogs.close()
 } catch(error){if(input.current()){warn(`${error instanceof Error ? error.message : "Reset request failed"} \xB7 retry keeps the same attempt`)
 input.dialogs.back()
-}} finally{setBusy(false)
-}}
-async function review(creditID){if(busy()||!input.current()||!input.adapter.prepareResetCreditConsumption||!input.adapter.consumeResetCredit)
-return
-setBusy(true)
-try{const snapshot=await input.adapter.prepareResetCreditConsumption(input.model,creditID,signal())
-if(!input.current()||snapshot.accountId!==input.model.accountID)
+}}}
+async function review(creditID){try{const snapshot=await model.review(creditID)
+if(!snapshot)
 return
 input.dialogs.open(()=>_$createComponent2(GuardedConfirmation2,{get api(){return input.api
 },get current(){return input.current
@@ -522,7 +591,6 @@ input.dialogs.open(()=>_$createComponent2(GuardedConfirmation2,{get api(){return
 }))
 } catch(error){if(input.current())
 warn(error instanceof Error?error.message:"Credit eligibility is unavailable")
-} finally{setBusy(false)
 }}
 return{review,consume,busy
 }}
@@ -677,13 +745,13 @@ setRevision((value)=>value + 1)
 }),context.data.on("server.connected",()=>{generation++
 setRevision((value)=>value + 1)
 })]
-const adapter={id:"opencode-usage",name:"OpenCode workspace limits",supports:(model)=>typeof context.client.usage?.limits==="function"&&provider(model)?.integrationID==="opencode",async read(model,signal){signal.throwIfAborted()
+const adapter={id:"opencode-usage",name:"OpenCode workspace limits",supports:(model)=>typeof context.client.experimental?.usage?.limits==="function"&&provider(model)?.integrationID==="opencode",async read(model,signal){signal.throwIfAborted()
 const epoch=generation
 const target=key()
 const activeProvider=provider(model)
 if(!activeProvider||activeProvider.integrationID!=="opencode")
 throw new Error("Native usage provider changed")
-try{const result=await context.client.usage.limits({location:{directory:location().directory}},{signal})
+try{const result=await context.client.experimental.usage.limits({location:{directory:location().directory}},{signal})
 if(epoch!==generation||target!==key()||signal.aborted||result.location.directory!==location().directory)
 throw new DOMException("Workspace usage target changed","AbortError")
 if(!result.data)
@@ -920,35 +988,103 @@ import {createElement as _$createElement8} from "@opentui/solid"
 import {createComponent as _$createComponent11} from "@opentui/solid"
 import {memo as _$memo5} from "@opentui/solid"
 import {Show as Show5} from "solid-js"
-function LimitsStatus(props){const message=()=>{const model=props.controller.current().model
-const connection=model?.hostConnection
-const snapshot=props.controller.snapshot()
-const state=props.controller.state()
+import {createSignal as createSignal8} from "solid-js"
+function createProviderAccountSource(ports){const [connections,setConnections]=createSignal8({})
+let generation=0
+let disposed=false
+let lastModel
+let pending
+function save(target,connection){if(JSON.stringify(connections()[target])!==JSON.stringify(connection))
+setConnections((values)=>({...values,[target]:connection}))
+}
+async function read(model,signal=ports.lifecycle){if(disposed||ports.lifecycle.aborted||signal.aborted)
+return{status:"unavailable"}
+const target=ports.key(model)
+const epoch=generation
+if(pending?.key===target&&pending.generation===epoch)
+return pending.promise
+const promise=(async ()=>{try{const connection=await ports.read(model,AbortSignal.any([ports.lifecycle,signal]))
+if(disposed||ports.lifecycle.aborted||signal.aborted||epoch!==generation||ports.key(model)!==target)
+return{status:"unavailable"}
+save(target,connection)
+return connection
+} catch{if(!disposed&&!ports.lifecycle.aborted&&!signal.aborted&&epoch===generation)
+save(target,{status:"unavailable"})
+return{status:"unavailable"}}})()
+pending={key:target,generation:epoch,promise}
+try{return await promise
+} finally{if(pending?.promise===promise)
+pending=undefined
+}}
+const unsubscribe=ports.subscribe((eager=true)=>{generation++
+if(eager)
+setConnections({})
+else{const active=lastModel&&ports.key(lastModel)
+setConnections((values)=>Object.fromEntries(Object.entries(values).filter(([target])=>target===active)))
+}
+if(lastModel&&!disposed)
+read(lastModel)
+})
+return{suspend(){if(!lastModel)
+return
+lastModel=undefined
+generation++
+pending=undefined
+},current(model){lastModel=model
+return{...model,hostConnection:connections()[ports.key(model)]??{status:"loading"}}},async refresh(model){await read(model)
+},async validate(model,signal){const actual=await read(model,signal)
+const expected=model.hostConnection
+return actual.status==="ready"&&expected?.status==="ready"&&actual.id===expected.id&&actual.accountID===expected.accountID&&(!actual.accountID||actual.accountID===model.accountID)
+},dispose(){disposed=true
+generation++
+unsubscribe()
+}}}
+function bindCodexAccount(model,preferences){const connection=model.hostConnection
+if(model.providerID!=="openai"&&connection?.providerID!=="openai"||connection?.method==="api")
+return{...model,accountID:undefined,accountSource:undefined}
+if(connection&&connection.status!=="ready")
+return{...model,accountID:undefined,accountSource:undefined}
+const accountID=connection?.accountID??preferences?.codexAccountForConnection(model.providerID,connection?.id,model.modelID)
+const accountSource=connection?.accountID?"host":"binding"
+return{...model,accountID,accountSource:accountID?accountSource:undefined}}
+import {createEffect as createEffect3,createMemo,on as on2,onCleanup as onCleanup2} from "solid-js"
+function quotaStatusMessage(input){const{model,snapshot,state}=input
 if(state.status==="error")
 return snapshot?"Stale \xB7 refresh failed":"Quota read failed \xB7 refresh to retry"
-if(snapshot?.availability==="ready"&&(snapshot.windows.length>0||snapshot.balances?.length))
+if(!input.showReadyMessage&&snapshot?.availability==="ready"&&(snapshot.windows.length>0||snapshot.balances?.length))
 return
-if(snapshot?.message)
-return snapshot.availability==="stale"?`Stale \xB7 ${snapshot.message}`:snapshot.availability==="ready"?`Updated ${new Date(snapshot.fetchedAt).toLocaleTimeString()} \xB7 ${snapshot.message}`:snapshot.message
+if(snapshot?.message){if(snapshot.availability==="stale")
+return `Stale \xB7 ${snapshot.message}`
+return snapshot.availability==="ready"?`Updated ${new Date(snapshot.fetchedAt).toLocaleTimeString()} \xB7 ${snapshot.message}`:snapshot.message
+}
+const connection=model?.hostConnection
 if(connection?.status==="loading")
 return "Checking the OpenCode account\u2026"
 if(connection?.status==="unavailable")
 return "Account metadata unavailable \xB7 refresh to retry"
 if(connection?.status==="unsupported")
 return "Codex quotas require an active ChatGPT OAuth connection"
-if(!snapshot)
-return state.status==="loading"?"Reading provider limits\u2026":props.controller.current().adapter?"Refresh to read provider limits":providerQuotaCapability(model?.providerID??"").reason
-const availability=snapshot.availability
-if(availability==="unauthenticated")
+if(!snapshot){if(state.status==="loading")
+return "Reading provider limits\u2026"
+return input.hasAdapter?"Refresh to read provider limits":providerQuotaCapability(model?.providerID??"").reason
+}
+if(snapshot.availability==="unauthenticated")
 return model?.accountSource==="host"?"Sign in to Codex CLI with the account selected in OpenCode":"Codex sign-in or linked account changed \xB7 relink below"
-if(availability==="unsupported")
+if(snapshot.availability==="unsupported")
 return "No documented quota bucket for this model"
-if(availability==="rate_limited")
+if(snapshot.availability==="rate_limited")
 return "Provider rate-limited this read \xB7 try again later"
-if(availability==="stale")
+if(snapshot.availability==="stale")
 return "Stale provider data \xB7 refresh to update"
+if(snapshot.availability==="ready"&&input.showReadyMessage&&(snapshot.windows.length>0||snapshot.balances?.length))
+return
 return `Updated ${new Date(snapshot.fetchedAt).toLocaleTimeString()}`
 }
+function LimitsStatus(props){const message=()=>{const{model,adapter
+}=props.controller.current()
+return quotaStatusMessage({model,snapshot:props.controller.snapshot(),state:props.controller.state(),hasAdapter:Boolean(adapter)
+})
+}
 return _$createComponent11(Show5,{get when(){return _$memo5(()=>!!props.controller.current().model)()&&message()
 },children:(value)=>(()=>{var _el$=_$createElement8("text")
 _$setProp8(_el$,"wrapMode","word")
@@ -966,10 +1102,10 @@ import {memo as _$memo6} from "@opentui/solid"
 import {insert as _$insert8} from "@opentui/solid"
 import {setProp as _$setProp9} from "@opentui/solid"
 import {createElement as _$createElement9} from "@opentui/solid"
-import {Show as Show6,createSignal as createSignal8} from "solid-js"
+import {Show as Show6,createSignal as createSignal9} from "solid-js"
 import {SelectionBox as SelectionBox3,useIcons as useIcons4} from "./tui.js"
 function Section(props){const icons=useIcons4()
-const [headerWidth,setHeaderWidth]=createSignal8(0)
+const [headerWidth,setHeaderWidth]=createSignal9(0)
 const icon=()=>props.section?icons.section(props.section):props.icon
 const theme=()=>props.api.theme.current
 const item=useSidebarItem(props.api,props.interaction,{id:props.sectionId??`section.${props.title}`,position:()=>({section:props.navigationSection??0,row:0,column:0
@@ -1062,7 +1198,7 @@ return _$createComponent13(Section,{get api(){return props.api
 },get navigationSection(){return props.navigationSection
 },get credits(){return(snapshot()?.bankedResets?.availableCount??0)>0||Boolean(props.preferences.pendingResetAttempt())
 },get refreshing(){return ["loading","refreshing"].includes(props.controller.state().status)
-},get canRefresh(){return Boolean(model()&&(props.controller.current().adapter||model()?.hostConnection?.status==="unavailable"))
+},get canRefresh(){return Boolean(model()&&(props.controller.current().adapter??model()?.hostConnection?.status==="unavailable"))
 },onCredits:openCredits,onRefresh:()=>void props.controller.refresh(true)
 })
 },get open(){return props.preferences.expanded().limits
@@ -1103,49 +1239,11 @@ const model=api.state.session.get(sessionID)?.model
 if(!model)
 return
 return{sessionID,providerID:model.providerID,modelID:model.id,...model.variant&&{variant:model.variant}}}
-import {createSignal as createSignal9,untrack as untrack2} from "solid-js"
-var CHATGPT_METHODS=new Set(["chatgpt-browser","chatgpt-headless"])
-function providerAccountIdentity(provider,credentials){if(!provider.integrationID||provider.activation==="disabled")
-return{status:"unsupported"}
-const active=credentials.filter((entry)=>entry.integrationID===provider.integrationID&&entry.active)
-if(active.length!==1)
-return{status:"unavailable"}
-const credential=active[0]
-const id=`credential:${credential.id}`
-if(credential.value.type==="external")
-return{status:"unsupported",id}
-const providerID=provider.canonical??provider.id
-if(credential.value.type==="key")
-return{status:"ready",id,method:"api",providerID}
-if(provider.integrationID!=="openai")
-return{status:"ready",id,method:"oauth",providerID}
-if(!CHATGPT_METHODS.has(credential.value.methodID))
-return{status:"unsupported",id}
-const account=credential.value.metadata?.accountID
-const accountID=typeof account==="string"&&account.trim()?account:undefined
-const header=Object.entries(provider.headers??{}).find(([name])=>name.toLowerCase()==="chatgpt-account-id")?.[1]
-if(accountID&&header&&header!==accountID)
-return{status:"loading"}
-return{status:"ready",id,method:"oauth",providerID,...accountID&&{accountID}}}
-function createOpenCodeV2AccountSource(context,lifecycle){const [connections,setConnections]=createSignal9({})
-let generation=0
-let disposed=false
-let lastModel
-let pending
-const location=()=>context.location??context.data.location.default()
-const key=(model)=>JSON.stringify([model.providerID,location()])
-function save(target,connection){if(JSON.stringify(connections()[target])!==JSON.stringify(connection))
-setConnections((values)=>({...values,[target]:connection}))
-}
-async function read(model,signal=lifecycle){if(disposed||signal.aborted)
-return{status:"unavailable"}
-const target=key(model)
-const epoch=generation
-if(pending?.key===target&&pending.generation===epoch)
-return pending.promise
-const promise=(async ()=>{try{if(!context.client.provider?.get||!context.client.credential?.list)
+import {untrack as untrack2} from "solid-js"
+function createOpenCodeV2AccountSource(context,lifecycle){const location=()=>context.location??context.data.location.default()
+return createProviderAccountSource({lifecycle,key:(model)=>JSON.stringify([model.providerID,location()]),async read(model,signal){if(!context.client.provider?.get||!context.client.credential?.list)
 throw new Error("Account metadata unavailable")
-const options={signal:AbortSignal.any([lifecycle,signal])}
+const options={signal}
 const [provider,credentials]=await Promise.all([context.client.provider.get({providerID:model.providerID,location:location()},options),context.client.credential.list(options)])
 let connection=provider.data.id===model.providerID?providerAccountIdentity(provider.data,credentials):{status:"unavailable"}
 if(connection.status==="unavailable"&&credentials.every((entry)=>!(entry.integrationID===provider.data.integrationID&&entry.active))&&provider.data.integrationID&&typeof context.client.integration?.get==="function"){const integration=await context.client.integration.get({integrationID:provider.data.integrationID,location:location()},options)
@@ -1153,56 +1251,17 @@ const active=integration.data.connections[0]
 if(active?.type==="env"&&!active.status)
 connection={status:"ready",id:`env:${active.name}`,method:"api",providerID:provider.data.canonical??provider.data.id
 }}
-if(disposed||signal.aborted||epoch!==generation||key(model)!==target)
-return{status:"unavailable"}
-save(target,connection)
 return connection
-} catch{if(!disposed&&!signal.aborted&&epoch===generation)
-save(target,{status:"unavailable"})
-return{status:"unavailable"}}})()
-pending={key:target,generation:epoch,promise}
-try{return await promise
-} finally{if(pending?.promise===promise)
-pending=undefined
-}}
-function invalidate(eager=true){generation++
-if(eager)
-setConnections({})
-else{const active=lastModel&&key(lastModel)
-setConnections((values)=>Object.fromEntries(Object.entries(values).filter(([target])=>target===active)))
-}
-if(lastModel&&!disposed)
-read(lastModel)
-}
-const events=["credential.switched","credential.updated","integration.updated","provider.updated","server.connected"]
-const unsubscribes=events.map((event)=>context.data.on(event,(observation)=>untrack2(()=>{const directory=observation?.location?.directory
+},subscribe(invalidate){const events=["credential.switched","credential.updated","integration.updated","provider.updated","server.connected"]
+const cleanups=events.map((event)=>context.data.on(event,(observation)=>untrack2(()=>{const directory=observation?.location?.directory
 if((event==="provider.updated"||event==="integration.updated")&&directory&&directory!==location().directory)
 return
 invalidate(event!=="provider.updated")
 })))
-return{suspend(){if(!lastModel)
-return
-lastModel=undefined
-generation++
-pending=undefined
-},current(model){lastModel=model
-return{...model,hostConnection:connections()[key(model)]??{status:"loading"}}},async refresh(model){await read(model)
-},async validate(model,signal){const actual=await read(model,signal)
-const expected=model.hostConnection
-return actual.status==="ready"&&expected?.status==="ready"&&actual.id===expected.id&&actual.accountID===expected.accountID&&(!actual.accountID||actual.accountID===model.accountID)
-},dispose(){disposed=true
-generation++
-for(const unsubscribe of unsubscribes)
-unsubscribe()
-}}}
-function bindCodexAccount(model,preferences){const connection=model.hostConnection
-if(model.providerID!=="openai"&&connection?.providerID!=="openai"||connection?.method==="api")
-return{...model,accountID:undefined,accountSource:undefined}
-if(connection&&connection.status!=="ready")
-return{...model,accountID:undefined,accountSource:undefined}
-const accountID=connection?.accountID??preferences.codexAccountForConnection(model.providerID,connection?.id,model.modelID)
-const accountSource=connection?.accountID?"host":"binding"
-return{...model,accountID,accountSource:accountID?accountSource:undefined}}
+return()=>{for(const cleanup of cleanups)
+cleanup()
+}}})
+}
 var commandName=(kind)=>kind==="model"?"model.list":"variant.list"
 function createLimitsModelSelection(api,current,context){const sameTarget=(model)=>{const active=current()
 return active?.sessionID===model.sessionID&&active.providerID===model.providerID&&active.modelID===model.modelID

package/dist/quick-actions-settings.js

@@ -1,5 +1,5 @@
 import {PLUGIN_ID
-} from "./chunk-bv0nm1tj.js";
+} from "./chunk-dm1y8x49.js";
 import {memo as _$memo} from "@opentui/solid"
 import {createComponent as _$createComponent} from "@opentui/solid"
 import {use as _$use} from "@opentui/solid"

package/dist/runtime-dependencies.json

@@ -1,10 +1,10 @@
 {
   "version": 1,
   "dependencies": {
-    "@opencode/plugin": "2.2.5",
-    "@opentui/core": "0.8.1",
-    "@opentui/keymap": "0.8.1",
-    "@opentui/solid": "0.8.1",
+    "@opencode/plugin": "2.2.6",
+    "@opentui/core": "0.8.3",
+    "@opentui/keymap": "0.8.3",
+    "@opentui/solid": "0.8.3",
     "solid-js": "1.9.18"
   }
 }