@toddzheng024/dscode-desktop 0.7.41 → 0.7.44

package/plugins/antigravity/wire.mjs

@@ -0,0 +1,155 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { LlmError, requestImageHandleText } from '@deepseek-ai/dsh-llm';
+import { thinkingConfig } from './models.mjs';
+
+export const REPLAY_KIND = 'dscode-antigravity';
+const textOf = blocks => blocks.filter(b => b.type === 'text').map(b => b.text).join('\n');
+const signature = value => typeof value === 'string' && value.length > 0;
+
+function imageParts(blocks, images) {
+  return blocks.flatMap(block => {
+    if (block.type === 'text') return block.text ? [{ text: block.text }] : [];
+    if (block.type !== 'image') return [];
+    const version = images?.versions.get(block.attachment.attachmentId);
+    if (!version) throw new LlmError('Antigravity image was not prepared by the attachment service', 'UNSUPPORTED_CONTENT');
+    return [{ text: requestImageHandleText(block.attachment, version, images.access?.(block.attachment)) },
+      { inlineData: { mimeType: version.mediaType, data: Buffer.from(version.data).toString('base64') } }];
+  });
+}
+
+/** Preserve signed model turns verbatim. On a provider/model switch, represent
+ * earlier unsigned calls as historical text, not fresh executable requests. */
+export function convertMessages(options, route, images) {
+  const contents = [], calls = new Map();
+  const append = (role, parts) => {
+    if (!parts.length) return;
+    if (contents.at(-1)?.role === role) contents.at(-1).parts.push(...parts);
+    else contents.push({ role, parts });
+  };
+  const result = (id, blocks, isError) => {
+    const call = calls.get(id), parts = imageParts(blocks, images);
+    const output = parts.filter(p => p.text !== undefined).map(p => p.text).join('\n') || '(no output)';
+    if (!call?.signed) {
+      append('user', [{ text: `Historical tool result (${call?.name ?? id}):\n${output}` }, ...parts.filter(p => p.inlineData)]);
+    } else {
+      append('user', [{ functionResponse: { name: call.name, response: { [isError ? 'error' : 'output']: output },
+        ...(parts.some(p => p.inlineData) ? { parts: parts.filter(p => p.inlineData) } : {}) } }]);
+    }
+  };
+  for (const message of options.messages) {
+    if (message.role === 'system') continue;
+    if (message.role === 'tool') { result(message.toolCallId, message.content, message.isError); continue; }
+    if (message.role !== 'assistant') {
+      for (const block of message.content) {
+        if (block.type === 'tool-result') result(block.toolCallId, block.content, block.isError);
+        else append('user', imageParts([block], images));
+      }
+      continue;
+    }
+    const source = message.source, replay = source?.replayState;
+    const same = source?.provider === options.provider && source?.model === options.model && replay?.response?.kind === REPLAY_KIND
+      && replay.response.runtimeModel === route.id && replay.blocks?.length === message.content.length;
+    const firstCall = message.content.findIndex(b => b.type === 'tool-call');
+    const signedCalls = same && firstCall >= 0 && signature(replay.blocks[firstCall]?.thoughtSignature);
+    const parts = [];
+    message.content.forEach((block, index) => {
+      const sig = same ? replay.blocks[index]?.thoughtSignature : undefined;
+      if (block.type === 'text') {
+        if (block.text || sig) parts.push({ text: block.text, ...(sig ? { thoughtSignature: sig } : {}) });
+      } else if (block.type === 'reasoning' && same) {
+        parts.push({ thought: true, text: block.text, ...(sig ? { thoughtSignature: sig } : {}) });
+      } else if (block.type === 'tool-call') {
+        calls.set(block.id, { name: block.name, signed: signedCalls });
+        if (signedCalls) {
+          let args;
+          try { args = JSON.parse(block.arguments); } catch { throw new LlmError('Invalid saved Antigravity tool arguments', 'INVALID_REQUEST'); }
+          parts.push({ functionCall: { name: block.name, args }, ...(sig ? { thoughtSignature: sig } : {}) });
+        } else parts.push({ text: `Historical tool call: ${block.name}(${block.arguments})` });
+      }
+    });
+    append('model', parts);
+  }
+  if (!contents.length || contents[0].role !== 'user') contents.unshift({ role: 'user', parts: [{ text: 'Continue using the following conversation history.' }] });
+  if (contents.at(-1).role === 'model') append('user', [{ text: 'Continue the active task.' }]);
+  return contents;
+}
+
+export function requestBody(options, model, route, project, images) {
+  const contents = convertMessages(options, route, images);
+  const system = [options.system, ...options.messages.filter(m => m.role === 'system').map(m => textOf(m.content))].filter(Boolean).join('\n\n');
+  const seed = options.sessionId ?? createHash('sha256').update(JSON.stringify(contents[0])).digest('hex');
+  const hash = createHash('sha256').update(String(seed)).digest('hex');
+  const trajectory = `${hash.slice(0, 8)}-${hash.slice(8, 12)}-4${hash.slice(13, 16)}-a${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
+  const step = contents.length;
+  const labels = { last_step_index: String(step - 1), request_id: `${trajectory}-${options.messages.filter(m => m.role === 'assistant').length}`,
+    trajectory_id: trajectory, used_claude: 'false', used_claude_conservative: 'false', used_non_gemini_model: 'false',
+    ...(route.modelEnum ? { model_enum: route.modelEnum } : {}) };
+  const thinking = thinkingConfig(route);
+  const tools = (options.tools ?? []).map(t => ({ name: t.name, description: t.description, parametersJsonSchema: t.parameters }));
+  return { project, model: route.id, requestType: 'agent', userAgent: 'antigravity',
+    requestId: `agent/${trajectory}/${Date.now()}/${trajectory}/${step}`,
+    request: { contents, sessionId: BigInt(`0x${hash.slice(0, 15)}`).toString(), labels,
+      ...(system ? { systemInstruction: { role: 'user', parts: [{ text: system }] } } : {}),
+      generationConfig: { maxOutputTokens: Math.min(options.maxTokens ?? model.maxTokens, model.maxTokens),
+        ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+        ...(options.stop ? { stopSequences: options.stop } : {}), ...(thinking ? { thinkingConfig: thinking } : {}) },
+      ...(tools.length ? { tools: [{ functionDeclarations: tools }] } : {}) } };
+}
+
+function usageOf(raw) {
+  const valid = n => Number.isSafeInteger(n) && n >= 0;
+  if (!valid(raw?.promptTokenCount) || !valid(raw?.candidatesTokenCount)) return undefined;
+  const cached = valid(raw.cachedContentTokenCount) ? raw.cachedContentTokenCount : 0;
+  const reasoning = valid(raw.thoughtsTokenCount) ? raw.thoughtsTokenCount : 0;
+  return { inputTokens: Math.max(0, raw.promptTokenCount - cached), outputTokens: raw.candidatesTokenCount + reasoning,
+    cacheReadTokens: cached, reasoningTokens: reasoning,
+    ...(valid(raw.totalTokenCount) ? { totalTokens: raw.totalTokenCount } : {}) };
+}
+
+/** No tool block is committed before a successful terminal marker. Partial
+ * streams fail so a disconnected call can never become a local side effect. */
+export async function* translate(payloads, { model, runtimeModel }) {
+  const blocks = [], metadata = [];
+  let active, finish, usage;
+  for await (const payload of payloads) {
+    if (payload === '[DONE]') break;
+    let packet;
+    try { packet = JSON.parse(payload); } catch { throw new LlmError('Malformed Antigravity stream', 'MALFORMED_RESPONSE'); }
+    if (packet.error || packet.response?.error) throw new LlmError('Antigravity returned a streaming error', 'SERVER');
+    const data = packet.response ?? packet, candidate = data.candidates?.[0];
+    if (data.promptFeedback?.blockReason) throw new LlmError('Antigravity blocked this request', 'CONTENT_FILTER');
+    for (const part of candidate?.content?.parts ?? []) {
+      // Google can send a signature in a separate part after its text/call.
+      if (!part.functionCall && part.text === undefined && signature(part.thoughtSignature) && active) {
+        metadata[active.index].thoughtSignature = part.thoughtSignature; continue;
+      }
+      const type = part.functionCall ? 'tool-call' : part.thought ? 'reasoning' : 'text';
+      if (!part.functionCall && part.text === undefined && !part.thoughtSignature) throw new LlmError('Unsupported Antigravity output part', 'UNSUPPORTED_CONTENT');
+      if (finish) throw new LlmError('Antigravity emitted content after finishing', 'MALFORMED_RESPONSE');
+      if (!active || active.block.type !== type || type === 'tool-call' || active.closed) {
+        const block = type === 'tool-call' ? { type, id: randomUUID(), name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args ?? {}) } : { type, text: '' };
+        if (type === 'tool-call' && (typeof block.name !== 'string' || !block.name || part.functionCall.args !== undefined && (typeof part.functionCall.args !== 'object' || Array.isArray(part.functionCall.args) || part.functionCall.args === null))) throw new LlmError('Invalid Antigravity tool call', 'MALFORMED_RESPONSE');
+        active = { index: blocks.length, block }; blocks.push(block); metadata.push({ type });
+        yield { type: 'block-start', index: active.index, blockType: type };
+      }
+      if (part.thoughtSignature) metadata[active.index].thoughtSignature = part.thoughtSignature;
+      if (type === 'tool-call') {
+        yield { type: 'tool-call-delta', index: active.index, id: active.block.id, name: active.block.name, argumentsDelta: active.block.arguments };
+        active.closed = true;
+      } else if (typeof part.text === 'string') {
+        active.block.text += part.text;
+        yield { type: type === 'text' ? 'text-delta' : 'reasoning-delta', index: active.index, text: part.text };
+      }
+    }
+    if (candidate?.finishReason) finish = candidate.finishReason;
+    usage = usageOf(data.usageMetadata) ?? usage;
+  }
+  if (!finish) throw new LlmError('Antigravity stream ended before completion', 'TRANSPORT');
+  if (!['STOP', 'MAX_TOKENS'].includes(finish)) throw new LlmError('Antigravity did not complete the response', finish === 'SAFETY' ? 'CONTENT_FILTER' : 'MALFORMED_RESPONSE');
+  if (!blocks.length) throw new LlmError('Antigravity returned no content', 'EMPTY_RESPONSE');
+  if (finish === 'MAX_TOKENS' && blocks.some(b => b.type === 'tool-call')) throw new LlmError('Antigravity tool response reached the token limit; retry with a larger output budget', 'MALFORMED_RESPONSE');
+  for (let index = 0; index < blocks.length; index++) yield { type: 'block-end', index, block: blocks[index] };
+  if (usage) yield { type: 'usage', usage };
+  yield { type: 'finish', reason: { kind: finish === 'MAX_TOKENS' ? 'max-tokens' : blocks.some(b => b.type === 'tool-call') ? 'tool-calls' : 'stop' },
+    replayState: { response: { kind: REPLAY_KIND, version: 1, model, runtimeModel }, blocks: metadata } };
+}

package/plugins/compaction/engine.mjs

@@ -1,7 +1,7 @@
 import { BasicCompactionEngine } from '@deepseek-ai/dsh-compaction-basic';
 import { ManualCompactionError, toolPairingBalancedBefore } from '@deepseek-ai/dsh-compaction';
 import { SessionSeq } from '@deepseek-ai/dsh-session';
-import { effectiveContextWindow, fitsInWindow, prefetchThresholdTokens, pricedCompactionPolicy } from './threshold.mjs';
+import { effectiveContextWindow, fitsInWindow, prefetchThresholdTokens, pricedCompactionPolicy, compactionThresholdTokens } from './threshold.mjs';
 
 // DSCODE's compaction policy as a subclass of the upstream engine instead of a
 // build-time patch of its source. It owns exactly the decisions this deployment
@@ -157,8 +157,9 @@ export class DscodeCompactionEngine extends BasicCompactionEngine {
   dscodeCompactSpec(policy, contextWindow) {
     const key = `${policy.target.provider}/${policy.target.model}`;
     if (!Number.isInteger(contextWindow) || contextWindow <= 0) throw new Error(`compaction: contextWindow (${contextWindow}) must be a positive integer for ${key}`);
-    const thresholdTokens = Math.floor(contextWindow * policy.thresholdRatio);
-    const retainTokens = policy.retainTokens === undefined ? Math.floor(contextWindow * policy.retainRatio) : policy.retainTokens;
+    const thresholdTokens = compactionThresholdTokens(policy.target.provider, policy.target.model, contextWindow, policy.thresholdRatio);
+    const retentionWindow = Math.min(contextWindow, thresholdTokens / policy.thresholdRatio);
+    const retainTokens = policy.retainTokens === undefined ? Math.floor(retentionWindow * policy.retainRatio) : policy.retainTokens;
     if (retainTokens >= thresholdTokens) throw new Error(`compaction: retainTokens (${retainTokens}) must be less than threshold tokens ${thresholdTokens} for ${key}`);
     return { ...policy, contextWindow, thresholdTokens, retainTokens };
   }

package/plugins/compaction/threshold.mjs

@@ -9,6 +9,14 @@ import { ensureOpenRouterModels } from '../openrouter/models.mjs';
 // so compaction waits; with no discount it pays off early.
 export const DEFAULT_THRESHOLD_RATIO = 0.8;
 
+// A pressure trigger, not an advertised model capacity. Smaller models still
+// compact earlier when their safe input budget requires it.
+export const CODEX_COMPACTION_TOKENS = 272000;
+export function compactionThresholdTokens(provider, model, contextWindow, thresholdRatio) {
+  const ordinary = Math.floor(contextWindow * thresholdRatio);
+  return provider === 'openai' ? Math.min(CODEX_COMPACTION_TOKENS, ordinary) : ordinary;
+}
+
 /** Threshold ratio for a cache-read / input price ratio; unknown prices keep the upstream default. */
 export function thresholdForCacheRatio(ratio) {
   if (!Number.isFinite(ratio) || ratio < 0) return DEFAULT_THRESHOLD_RATIO;
@@ -92,8 +100,8 @@ export async function pricedCompactionPolicy(config, policy, now = Date.now()) {
 }
 
 /** Whether the session's current context would compact on a route's next step, or undefined when either size is unknown. */
-export function compactionPreview({ used, contextWindow, thresholdRatio, label = '' }) {
+export function compactionPreview({ used, contextWindow, thresholdRatio, label = '', provider, model }) {
   if (!Number.isFinite(used) || used <= 0 || !Number.isInteger(contextWindow) || contextWindow <= 0) return undefined;
-  const threshold = Math.floor(contextWindow * thresholdRatio);
+  const threshold = compactionThresholdTokens(provider, model, contextWindow, thresholdRatio);
   return { label, used, contextWindow, thresholdRatio, threshold, compacts: used >= threshold, overflows: used >= contextWindow };
 }

package/plugins/credentials/index.mjs

@@ -53,6 +53,13 @@ export default class DscodeCredentials extends LocalCredentialProvider {
     return super.resolve(ref);
   }
   async describe(ref) {
+    if (ref === 'OPENAI_API_KEY') {
+      const openai = this.ctx.get('dscodeOpenAI');
+      if (openai) {
+        const state = openai.auth.status();
+        if (state.mode === 'chatgpt') return { configured: state.configured, source: 'account', writable: false };
+      }
+    }
     if (this.desktop) {
       const native = await super.describe(ref);
       if (native.configured) return LOGINS.has(ref) ? { ...native, source: 'account', writable: false } : native;

package/plugins/dscode/index.mjs

@@ -12,7 +12,8 @@ import { withChildTarget } from './child-target.mjs';
 import { registerStatus } from '../status/index.mjs';
 export const name = 'dscode-execution-policy';
 export const inject = ['systemPrompt', 'tools', 'agents', 'commands', 'terminals', 'subagents', 'llm'];
-export const SHELL_POLICY = `Use bash as the persistent shell for reading, searching and modifying files. Prefer rg/rg --files, sed and standard CLI tools. Use apply_patch with a standard unified diff on stdin (git apply format, a/ and b/ paths); apply_patch --check validates before writing. It is not the *** Begin Patch format. Quote heredoc delimiters to avoid shell interpolation.
+export const SHELL_POLICY = `Use read to inspect text files (offset is 1-based; limit selects a line window), edit for targeted literal replacements (old_string/new_string), and write to create files or intentionally replace their full contents. Read an existing file before editing or overwriting it; a shell read or search does not satisfy the file-version guard. Successful edits and writes update that observation. If a file changed externally, re-read it and reconcile the changes before retrying. If old_string has multiple matches, add enough context to make it unique or use replace_all only when every occurrence should change. Never switch to a shell edit just to bypass a stale-file, unread-file or permission rejection. Observations do not survive session resume. File-tool relative paths resolve against the session workspace, not the persistent shell's current directory; prefer absolute paths when mixing the two.
+Use bash as the persistent shell for rg/rg --files searches, builds, tests and batch operations. Commands receive EOF on stdin unless a pipeline, heredoc or redirection provides input. Use non-interactive flags; this tool cannot answer terminal prompts. For changes that need a multi-file patch, apply_patch remains available with a standard unified diff on stdin (git apply format, a/ and b/ paths); apply_patch --check validates before writing. It is not the *** Begin Patch format and does not use the file tools' observed-version guard. Quote heredoc delimiters to avoid shell interpolation.
 Each agent has its own persistent shell, initially in the session workspace. cd, exported variables, functions and background jobs persist only while this shell lives. Timeout, cancellation, exit, /shell reset and process restart discard shell state; resume restores conversation, not an OS process. Never assume an environment from a past session still exists. Inspect pwd when paths matter. Keep long-running processes controlled and clean them up when done.
 Normal bash remains confined by the active sandbox. After a genuine sandbox denial, shell_retry provides a fresh, one-shot shell with the existing approval/escalation mechanism. Set an explicit absolute workdir and reconstruct needed non-secret setup; it does not inherit the persistent shell's cd, exports, functions or jobs. Use existing credential-aware CLIs; never paste secrets into arguments. Approval rejection is final for that action; do not work around it.
 Delegation to child agents (subagent, subagent_fork) is available at every effort. Below ultra, delegation is the exception: do the work in this agent by default. Delegate only a substantial, independent part of the task whose parallel work clearly shortens completion, or a broad read-only investigation that would otherwise crowd this context; never delegate a bounded edit, a single-file change, a quick lookup, one test run or a routine review. Below ultra run at most one child at a time, give it a bounded objective, choose the lowest reasoning_effort the model offers that fits, and verify and integrate its result yourself. Ultra adds its own delegation guidance to the request; the preset allows one delegation level and the runtime caps a parent at five concurrently running children below ultra and twenty at ultra.`;
@@ -60,7 +61,7 @@ const childLimit = owner => (owner.session.requestHeader?.()?.config ?? owner.op
 // repository there instead of pointing at a path that does not exist.
 const DOCS_DIR = fileURLToPath(new URL('../../docs/', import.meta.url));
 const DOCS_REPO = 'https://github.com/qiz029/dscode/blob/main/docs/';
-export const DOCS_SECTION = `To answer questions about DSCODE itself - what it supports, how a feature is configured, what a command does - treat the bundled user guides as the source of truth instead of guessing: ${existsSync(DOCS_DIR) ? `${DOCS_DIR} plus the repository root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, acp.md, email.md, browser-use.md, plugin-hub.md, computer-use.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, account-login.md, opencode-go.md, custom-providers.md, demo.md, triggers.md)` : `the repository documentation at ${DOCS_REPO} plus the root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, acp.md, email.md, browser-use.md, plugin-hub.md, computer-use.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, account-login.md, opencode-go.md, custom-providers.md, demo.md, triggers.md)`}. Read the relevant guide before answering rather than relying on memory of an earlier session. docs/CONTEXT-HANDOFF.md, docs/session-messaging-design.md, docs/cloud-webapp-host.md, docs/triggers-design.md, docs/verification.md, docs/maintainability.md and docs/vendored-tui-upgrade.md are internal development records, not user documentation: never quote them to a user or treat them as a specification. When the guides do not cover something, describe only what the running installation actually does and say plainly that it is not documented.`;
+export const DOCS_SECTION = `To answer questions about DSCODE itself - what it supports, how a feature is configured, what a command does - treat the bundled user guides as the source of truth instead of guessing: ${existsSync(DOCS_DIR) ? `${DOCS_DIR} plus the repository root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, acp.md, email.md, browser-use.md, plugin-hub.md, computer-use.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, account-login.md, opencode-go.md, antigravity.md, openai.md, custom-providers.md, demo.md, triggers.md)` : `the repository documentation at ${DOCS_REPO} plus the root README.md (session-bridge.md, session-communication.md, session-cards.md, memory.md, exec.md, acp.md, email.md, browser-use.md, plugin-hub.md, computer-use.md, skills.md, tui-commands.md, session-metrics.md, dscode-ultra.md, auto-review.md, account-login.md, opencode-go.md, antigravity.md, openai.md, custom-providers.md, demo.md, triggers.md)`}. Read the relevant guide before answering rather than relying on memory of an earlier session. docs/CONTEXT-HANDOFF.md, docs/session-messaging-design.md, docs/cloud-webapp-host.md, docs/triggers-design.md, docs/verification.md, docs/maintainability.md and docs/vendored-tui-upgrade.md are internal development records, not user documentation: never quote them to a user or treat them as a specification. When the guides do not cover something, describe only what the running installation actually does and say plainly that it is not documented.`;
 
 export function apply(ctx, config = {}) {
   registerStatus(ctx);

package/plugins/openai/adapter.mjs

@@ -0,0 +1,52 @@
+import { LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { isAttachmentError } from '@deepseek-ai/dsh-attachment';
+import { sseData } from '../providers/chat-stream.mjs';
+import { prepareImages } from '../custom/images.mjs';
+import { API, responseError } from './http.mjs';
+import { requestBody, translate } from './wire.mjs';
+export class OpenAIAdapter extends LlmAdapter {
+  constructor(config) { super(); this.config = config; }
+  providerInfo(provider) { return { id: provider, name: 'OpenAI / ChatGPT' }; }
+  providerRetryPolicy() { return this.config.options().retryPolicy; }
+  async listModels(provider) { return (await this.config.models.list()).map(m => ({ provider, id: m.id, name: m.name, inputModalities: m.inputModalities })); }
+  async resolveModel(provider, id) {
+    const m = await this.config.models.get(id);
+    return { provider, id, name: m.name, context: { contextWindow: m.contextWindow }, defaultMaxTokens: m.maxTokens, inputModalities: m.inputModalities,
+      ...(m.efforts.length ? { reasoning: { efforts: m.efforts.map(id => ({ id: ReasoningEffortId(id), name: id })), defaultEffort: ReasoningEffortId(m.efforts.includes(m.defaultEffort) ? m.defaultEffort : m.efforts[0]) } } : {}) };
+  }
+  async *stream(options) {
+    const config = this.config, settings = config.options(), controller = new AbortController();
+    const signal = AbortSignal.any([controller.signal, ...(options.signal ? [options.signal] : [])]);
+    const release = config.registerRequest?.(controller);
+    let timer, timedOut = false;
+    const pulse = ms => { clearTimeout(timer); timer = setTimeout(() => { timedOut = true; controller.abort(); }, ms); timer.unref?.(); };
+    try {
+      const auth = await config.auth.acquire(signal), model = await config.models.get(options.model, auth, signal);
+      const images = await prepareImages(options.messages, model, config.resolveAttachments?.(), config.resolveImageAccess, signal);
+      const requested = config.speed(options), body = requestBody({ ...options, messages: images.messages }, model, auth, requested, images);
+      signal.throwIfAborted(); pulse(settings.headerTimeoutMs);
+      const response = await config.fetch(API + '/responses', { method: 'POST', redirect: 'error', headers: { authorization: 'Bearer ' + auth.token, 'content-type': 'application/json', accept: 'text/event-stream' }, body: JSON.stringify(body), signal });
+      if (!response.ok) { let data; try { data = await response.json(); } catch {} throw responseError(response.status, data, response.headers.get('x-request-id')); }
+      const mediaType = response.headers.get('content-type')?.split(';')[0].trim().toLowerCase();
+      // The ChatGPT direct route can deliver valid SSE without Content-Type.
+      // Missing metadata is not proof of a malformed body: the translator still
+      // requires response.completed and validates every item before committing.
+      if (!response.body || mediaType && mediaType !== 'text/event-stream') {
+        const label = mediaType && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(mediaType) ? mediaType.slice(0,100) : 'unknown content type';
+        throw new LlmError(`OpenAI did not return a stream (HTTP ${response.status}; ${response.body ? label : 'empty body'})`, 'MALFORMED_RESPONSE');
+      }
+      pulse(settings.streamIdleTimeoutMs);
+      for await (const chunk of translate(sseData(response.body, () => pulse(settings.streamIdleTimeoutMs)), { model: model.id, account: auth.key, requested: body.service_tier })) {
+        signal.throwIfAborted();
+        clearTimeout(timer); yield chunk; pulse(settings.streamIdleTimeoutMs);
+      }
+    } catch (error) {
+      if (options.signal?.aborted) throw new LlmError('OpenAI request cancelled', 'ABORTED');
+      if (timedOut) throw new LlmError('OpenAI connection timed out; retry', 'TIMEOUT');
+      if (controller.signal.aborted) throw new LlmError('OpenAI account changed or signed out', 'ABORTED');
+      if (isAttachmentError(error)) throw new LlmError('OpenAI image input failed: ' + error.code, error.code);
+      if (error instanceof LlmError) throw error;
+      throw new LlmError('Could not complete the OpenAI request', 'TRANSPORT');
+    } finally { clearTimeout(timer); controller.abort(); release?.(); }
+  }
+}

package/plugins/openai/auth.mjs

@@ -0,0 +1,81 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { createHash } from 'node:crypto';
+import { tokenRequest } from './http.mjs';
+import { tokenFields } from './oauth.mjs';
+const terminal = new Set(['invalid_grant','invalid_refresh_token','token_expired','refresh_token_expired','refresh_token_invalidated','refresh_token_reused']);
+const strip = account => { const { access: _access, refresh: _refresh, expires: _expires, idToken: _idToken, scopes: _scopes, ...registration } = account; return registration; };
+export class OpenAIAuth {
+  constructor({ store, apiKey, verifier, fetch = globalThis.fetch }) { Object.assign(this, { store, apiKey, verifier, fetch }); }
+  status() {
+    const data = this.store.read();
+    const account = data?.accounts.find(a => a.clientId === data.active);
+    return { mode: data?.mode ?? 'chatgpt', account, accounts: data?.accounts ?? [], configured: Boolean(account?.access && account.scopes?.includes('chatgpt.tokens.use.direct')) };
+  }
+  async select(mode, id) {
+    return this.store.locked(data => {
+      if (mode === 'chatgpt' && id && !data.accounts.some(a => a.clientId === id)) throw Error('Unknown OpenAI account');
+      data.mode = mode; if (id) data.active = id; delete data.pendingRegistration; data.revision++; this.store.write(data);
+    });
+  }
+  async rememberRegistration(clientId, tx, signal) {
+    if (tx.clientId !== 'dynamic_agent_client') return;
+    return this.store.locked(data => {
+      if (data.revision !== tx.revision || signal?.aborted) return;
+      // A callback's client ID is a retry hint, not a verified account or grant.
+      data.pendingRegistration = { clientId, revision: data.revision };
+      this.store.write(data);
+    }, signal);
+  }
+  async save(account, tx, signal) {
+    return this.store.locked(data => {
+      if (data.revision !== tx.revision || signal?.aborted) return false;
+      const old = data.accounts.find(a => a.clientId === account.clientId);
+      if (old && old.subject !== account.subject) throw Error('OpenAI registration identity changed');
+      data.accounts = data.accounts.filter(a => a.clientId !== account.clientId); data.accounts.push(account);
+      data.active = account.clientId; data.mode = 'chatgpt'; delete data.pendingRegistration; data.revision++; this.store.write(data); return true;
+    }, signal);
+  }
+  async acquire(signal) {
+    const status = this.status();
+    if (status.mode === 'api-key') {
+      const key = await this.apiKey();
+      if (!key || /\s/.test(key)) throw new LlmError('Configure OPENAI_API_KEY with /login openai or in the launch environment', 'MISSING_CREDENTIAL');
+      return { mode: 'api-key', token: key, key: 'api-key:' + createHash('sha256').update(key).digest('hex') };
+    }
+    // Hold the kernel lock across refresh, re-read after admission, then commit
+    // the rotating token as a single atomic replacement. Other Hosts wait.
+    return this.store.locked(async data => {
+      if (data.mode !== 'chatgpt') throw new LlmError('OpenAI billing selection changed; retry', 'AUTH');
+      let account = data.accounts.find(a => a.clientId === data.active);
+      if (!account?.access || !account.refresh) throw new LlmError('Run /openai login to sign in with ChatGPT', 'MISSING_CREDENTIAL');
+      if (account.expires - Date.now() < 60000) {
+        try {
+          const token = await tokenRequest({ grant_type: 'refresh_token', client_id: account.clientId, refresh_token: account.refresh }, this.fetch, signal);
+          if (token.id_token) await this.verifier.verify(token.id_token, account, { refresh: true });
+          account = { ...account, ...tokenFields(token, account) };
+          data.accounts = data.accounts.map(a => a.clientId === account.clientId ? account : a); this.store.write(data);
+        } catch (error) {
+          if (terminal.has(error.oauthCode)) { data.accounts = data.accounts.map(a => a.clientId === account.clientId ? strip(a) : a); this.store.write(data); }
+          throw error;
+        }
+      }
+      if (!account.scopes.includes('chatgpt.tokens.use.direct')) throw new LlmError('ChatGPT plan usage is not enabled. Run /openai consent or choose /openai api-key', 'AUTH');
+      return { mode: 'chatgpt', token: account.access, key: account.clientId + ':' + account.subject };
+    }, signal);
+  }
+  async logout() {
+    return this.store.locked(async data => {
+      const account = data.accounts.find(a => a.clientId === data.active); let revoked = !account?.refresh;
+      if (account?.refresh) {
+        try {
+          const config = await this.verifier.discovery();
+          const response = await this.fetch(config.revocation_endpoint, { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(15000),
+            headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ token: account.refresh, token_type_hint: 'refresh_token', client_id: account.clientId }) });
+          revoked = response.status === 200;
+        } catch { /* local sign-out still completes */ }
+        data.accounts = data.accounts.map(a => a.clientId === account.clientId ? strip(a) : a);
+      }
+      delete data.pendingRegistration; data.revision++; this.store.write(data); return revoked;
+    });
+  }
+}

package/plugins/openai/command.mjs

@@ -0,0 +1,66 @@
+import { openBrowser } from '../account/index.mjs';
+import { transaction, callbackServer, exchangeCode } from './oauth.mjs';
+export class OpenAILogin {
+  constructor({ auth, models, open = openBrowser, callback = callbackServer, exchange = exchangeCode, cancelRequests = () => {} }) { Object.assign(this, { auth, models, open, callback, exchange, cancelRequests }); }
+  status() {
+    const s = this.auth.status();
+    return [`Billing: ${s.mode === 'api-key' ? 'OpenAI API key' : 'ChatGPT plan'}.`, this.attempt ? this.attempt.phase === 'exchange' ? 'Browser authorization received; exchanging and validating credentials.' : 'Waiting for browser sign-in; /openai cancel to stop.' : this.outcome,
+      s.mode === 'chatgpt' ? s.configured ? `Signed in: ${s.account.email ?? 'ChatGPT account'} [${s.account.clientId}].` : 'ChatGPT plan access is not active. Use /openai login or /openai consent.' : 'Configure the key with /login openai or OPENAI_API_KEY.',
+      'Usage and app permissions: https://chatgpt.com/settings/usage'].filter(Boolean).join('\n');
+  }
+  async login(arg) {
+    if (this.attempt) return this.status();
+    // Claim the attempt before asynchronous storage work so repeated commands
+    // cannot open two browsers with different PKCE verifiers.
+    const attempt = { controller: new AbortController() }; this.attempt = attempt; this.outcome = undefined;
+    try {
+      const data = await this.auth.store.initialize();
+      if (this.attempt !== attempt) return this.status();
+      const pending = data.pendingRegistration?.revision === data.revision ? data.pendingRegistration : undefined;
+      const account = arg === 'new' ? undefined : pending ?? data.accounts.find(a => a.clientId === data.active);
+      const tx = transaction(data, account, arg === 'consent'); attempt.tx = tx;
+      attempt.listener = await this.callback(tx, { signal: attempt.controller.signal });
+      if (this.attempt !== attempt) { attempt.listener.close(); return this.status(); }
+      attempt.done = this.follow(attempt);
+      await this.open(attempt.listener.url).catch(() => false);
+      return 'Continue with ChatGPT in your browser. Waiting up to 5 minutes; /openai status checks the result.\n' + attempt.listener.url;
+    } catch { if (this.attempt === attempt) this.attempt = undefined; throw Error('Could not start the OpenAI loopback login'); }
+  }
+  async follow(attempt) {
+    try {
+      const callback = await attempt.listener.result;
+      if (this.attempt !== attempt || attempt.controller.signal.aborted) return;
+      attempt.phase = 'exchange';
+      await this.auth.rememberRegistration(callback.clientId, attempt.tx, attempt.controller.signal);
+      const account = await this.exchange(callback, attempt.tx, this.auth.verifier, this.auth.fetch, attempt.controller.signal);
+      if (this.attempt !== attempt || attempt.controller.signal.aborted) return;
+      if (await this.auth.save(account, attempt.tx, attempt.controller.signal)) {
+        this.cancelRequests();
+        this.models.clear(); this.outcome = account.scopes.includes('chatgpt.tokens.use.direct') ? 'ChatGPT sign-in completed. Use /provider openai.' : 'Signed in, but plan usage was not granted. Use /openai consent or /openai api-key.';
+      } else this.outcome = 'Account selection changed during sign-in; retry /openai login.';
+    } catch (error) {
+      if (this.attempt === attempt) this.outcome = 'OpenAI sign-in failed. ' + (error.code ? error.message : 'Retry /openai login.')
+        + (error.oauthCode === 'invalid_grant' ? '\nAuthorization code rejected. Run /openai login again for a fresh code; the issued client registration is retained. Do not reuse the previous browser URL.' : '');
+    }
+    finally { attempt.listener.close(); if (this.attempt === attempt) this.attempt = undefined; }
+  }
+  cancel() { this.attempt?.controller.abort(); this.attempt?.listener?.close(); this.attempt = undefined; this.outcome = 'OpenAI sign-in cancelled.'; }
+  dispose() { this.cancel(); }
+}
+export function openaiCommand(login) {
+  return { name: 'openai', description: 'ChatGPT account sign-in and OpenAI billing selection', input: { hint: '[login [new]|status|accounts|use <id>|consent|api-key|models|logout|cancel]' }, handler: async ({ rawInput }) => {
+    const [action = 'status', arg] = String(rawInput ?? '').trim().split(/\s+/).filter(Boolean);
+    try {
+      let text;
+      if (action === 'login' || action === 'consent') text = await login.login(action === 'consent' ? 'consent' : arg);
+      else if (action === 'status') text = login.status();
+      else if (action === 'accounts') text = login.auth.status().accounts.map(a => `${a.clientId}: ${a.email ?? 'ChatGPT account'}${a.access ? '' : ' (signed out)'}`).join('\n') || 'No saved registrations. /openai login';
+      else if (action === 'cancel') { login.cancel(); text = login.outcome; }
+      else if (action === 'logout') { login.cancel(); login.cancelRequests(); const revoked = await login.auth.logout(); login.models.clear(); text = 'Local ChatGPT tokens removed; the registration is retained for future sign-in.' + (revoked ? '' : '\nRemote revocation was not confirmed. Disconnect DSCODE at https://chatgpt.com/settings/usage'); }
+      else if (action === 'api-key' || action === 'use' && arg) { login.cancel(); login.cancelRequests(); await login.auth.select(action === 'api-key' ? 'api-key' : 'chatgpt', arg); login.models.clear(); text = login.status(); }
+      else if (action === 'models') { const models = await login.models.list(true); text = [login.models.discovered ? 'OpenAI account model catalog' : 'Fallback catalog; access is unverified.', login.models.error, ...models.map(m => `${m.id}: ${m.tiers.map(t => t.id).join('/')} speed; ${m.contextWindow} context; auto-compact at 272000 tokens or earlier for smaller models`)].filter(Boolean).join('\n'); }
+      else return { kind: 'error', text: 'Usage: /openai [login [new]|status|accounts|use <id>|consent|api-key|models|logout|cancel]' };
+      return { kind: 'success', text };
+    } catch (error) { return { kind: 'error', text: error.code ? error.message : 'OpenAI operation failed. Check account selection and retry.' }; }
+  } };
+}

package/plugins/openai/http.mjs

@@ -0,0 +1,29 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+export const API = 'https://api.openai.com/v1';
+export const ISSUER = 'https://auth.openai.com';
+export const TOKEN_URL = ISSUER + '/api/accounts/oauth/token';
+export const REQUEST_MS = 15000;
+const safe = value => typeof value === 'string' && /^[a-zA-Z0-9_.:/-]{1,160}$/.test(value) ? value : undefined;
+export function responseError(status, data, requestId) {
+  const code = safe(data?.error?.code ?? (typeof data?.error === 'string' ? data.error : undefined));
+  const param = safe(data?.error?.param);
+  const category = code === 'subscription_sharing_usage_limit_exceeded' ? 'QUOTA'
+    : code?.includes('unsupported') ? 'INVALID_REQUEST'
+      : status === 401 || status === 403 ? 'AUTH' : status === 429 ? 'RATE_LIMIT' : status >= 500 ? 'SERVER' : 'INVALID_REQUEST';
+  const error = new LlmError(`OpenAI HTTP ${status}${code ? ': ' + code : ''}${param ? ' (' + param + ')' : ''}${safe(requestId) ? ' [request ' + requestId + ']' : ''}`, category);
+  error.oauthCode = code; error.status = status; return error;
+}
+export async function jsonRequest(url, init = {}, fetcher = globalThis.fetch) {
+  const signal = AbortSignal.any([AbortSignal.timeout(REQUEST_MS), ...(init.signal ? [init.signal] : [])]);
+  try {
+    const response = await fetcher(url, { ...init, redirect: 'error', signal });
+    let data; try { data = await response.json(); } catch { /* HTTP category still applies */ }
+    if (!response.ok) throw responseError(response.status, data, response.headers.get('x-request-id'));
+    if (!data || typeof data !== 'object') throw new LlmError('OpenAI returned invalid JSON', 'MALFORMED_RESPONSE');
+    return data;
+  } catch (error) {
+    if (error instanceof LlmError) throw error;
+    throw new LlmError(init.signal?.aborted ? 'OpenAI request cancelled' : signal.aborted ? 'OpenAI request timed out' : 'Could not contact OpenAI', init.signal?.aborted ? 'ABORTED' : signal.aborted ? 'TIMEOUT' : 'TRANSPORT');
+  }
+}
+export const tokenRequest = (body, fetcher, signal) => jsonRequest(TOKEN_URL, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ ...body, resource: API }), signal }, fetcher);

package/plugins/openai/index.mjs

@@ -0,0 +1,58 @@
+import { registerStartupCommand } from '../providers/startup-commands.mjs';
+import z from '@deepseek-ai/schemastery';
+import { dirname, join } from 'node:path';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { RetryPolicySchema, resolveRetryPolicy, resolveImageAttachmentAccess } from '@deepseek-ai/dsh-llm';
+import { plainConfig } from '../cordis-config/plain.mjs';
+import { currentCharge } from '../session-metrics/attribution.mjs';
+import { OpenAIStore } from './store.mjs';
+import { IdentityVerifier } from './oauth.mjs';
+import { OpenAIAuth } from './auth.mjs';
+import { OpenAIModels } from './models.mjs';
+import { OpenAIAdapter } from './adapter.mjs';
+import { OpenAILogin, openaiCommand } from './command.mjs';
+import { speedCommand, selectedSpeed, speedState, canonicalSpeed, setSpeedSource } from './speed.mjs';
+export const name = 'dscode-openai';
+export const inject = ['llm','credentials'];
+export const Config = z.object({
+  apiKeyEnv: z.union(['OPENAI_API_KEY']).role('credential-ref').default('OPENAI_API_KEY').volatile(),
+  serviceTier: z.union(['default','fast','ultrafast']).default('default').volatile(),
+  headerTimeoutMs: z.number().min(1).default(30000).volatile(),
+  streamIdleTimeoutMs: z.number().min(1).default(120000).volatile(),
+  retryPolicy: RetryPolicySchema.volatile(),
+});
+export function apply(ctx, config = {}) {
+  ctx.inject(['settings'], scoped => scoped.effect(() => scoped.settings.configure({ auto: false }, ctx.fiber)));
+  const options = () => { const value = plainConfig(config); return { serviceTier: value.serviceTier ?? 'default', headerTimeoutMs: value.headerTimeoutMs ?? 30000, streamIdleTimeoutMs: value.streamIdleTimeoutMs ?? 120000, retryPolicy: resolveRetryPolicy(value.retryPolicy, name) }; };
+  const directory = ctx.credentials.desktop ? resolveDshHome() : dirname(ctx.credentials.sharedConfig?.path ?? join(resolveDshHome(), 'credentials.yaml'));
+  const store = new OpenAIStore(join(directory, 'openai'));
+  const service = { fetch: (...args) => globalThis.fetch(...args), options };
+  const requests = new Set();
+  const cancelRequests = () => { for (const controller of requests) controller.abort(); };
+  ctx.effect(() => cancelRequests);
+  const fetcher = (...args) => service.fetch(...args);
+  service.auth = new OpenAIAuth({ store, apiKey: async () => (await ctx.credentials.resolve('OPENAI_API_KEY'))?.value, verifier: new IdentityVerifier(fetcher), fetch: fetcher });
+  service.models = new OpenAIModels(service.auth, fetcher);
+  service.login = new OpenAILogin({ auth: service.auth, models: service.models, cancelRequests });
+  const session = options => ctx.get('agents')?.get(options.sessionId ?? currentCharge()?.sessionId)?.session;
+  const adapter = new OpenAIAdapter({ auth: service.auth, models: service.models, options, fetch: fetcher,
+    registerRequest: controller => { requests.add(controller); return () => requests.delete(controller); },
+    speed: request => selectedSpeed(session(request), options().serviceTier),
+    resolveAttachments: () => ctx.get('attachments'),
+    resolveImageAccess: ref => { const attachments = ctx.get('attachments'); return attachments && resolveImageAttachmentAccess(attachments, path => ctx.get('fs')?.processPathFromHostPath(path), ref); },
+  });
+  ctx.provide('dscodeOpenAI', service);
+  ctx.effect(() => () => service.login.dispose());
+  ctx.inject(['commands'], scoped => { registerStartupCommand(scoped, openaiCommand(service.login)); registerStartupCommand(scoped, speedCommand(service)); });
+  ctx.inject(['agents'], scoped => scoped.effect(() => setSpeedSource((id, label) => {
+    const agent = scoped.agents.get(id); if (!agent) return '';
+    const route = agent.session.requestHeader()?.config ?? agent.options;
+    if (route.provider !== 'openai' || label && !label.includes(route.model)) return '';
+    const state = speedState(agent.session, route.model, options().serviceTier), selected = canonicalSpeed(state.requested);
+    return state.actual ? selected === canonicalSpeed(state.actual) ? selected : `${selected} → ${canonicalSpeed(state.actual)}` : `${selected} (unconfirmed)`;
+  })));
+  ctx.llm.registerConfigurableProviders([{ provider: 'openai', displayName: 'OpenAI / ChatGPT', settingsNs: ctx.fiber.entry?.options.id ?? name, settingsPath: [] }]);
+  const registration = ctx.llm.registerAdapter(['openai'], adapter);
+  let policy = JSON.stringify(options().retryPolicy);
+  ctx.on('loader/volatile-update', () => { const next = JSON.stringify(options().retryPolicy); if (next !== policy) { registration.replace(['openai']); policy = next; } });
+}

package/plugins/openai/models.mjs

@@ -0,0 +1,59 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { API, jsonRequest } from './http.mjs';
+export const PROVIDER = 'openai';
+const speed = id => ({ id, name: id === 'default' ? 'Standard' : id === 'priority' || id === 'fast' ? 'Fast' : id === 'ultrafast' ? 'Ultrafast' : id });
+const model = (id, name) => ({ id, name, contextWindow: 1050000, maxTokens: 128000, inputModalities: ['text','image'], efforts: ['low','medium','high','xhigh','max'], defaultEffort: 'medium', tiers: ['default','fast','ultrafast'].map(speed) });
+export const FALLBACK_MODELS = [model('gpt-6.1-sol','GPT-6.1 Sol'), model('gpt-6-astra','GPT-6 Astra')];
+const positive = n => Number.isSafeInteger(n) && n > 0;
+export function parseModels(data) {
+  const rows = Array.isArray(data.models) ? data.models : Array.isArray(data.data) ? data.data : undefined;
+  if (!rows) throw new LlmError('Invalid OpenAI model catalog', 'MALFORMED_RESPONSE');
+  return rows.flatMap(raw => {
+    const id = raw.slug ?? raw.id;
+    if (typeof id !== 'string' || !/^(gpt-|o[1-9]|codex-)[a-zA-Z0-9._-]*$/.test(id) || /audio|realtime|image|transcri|tts|search|chat-latest|instruct/.test(id) || raw.visibility && raw.visibility !== 'list') return [];
+    const known = FALLBACK_MODELS.find(m => m.id === id);
+    const efforts = (raw.supported_reasoning_levels ?? raw.supported_reasoning_efforts ?? known?.efforts ?? []).map(e => typeof e === 'string' ? e : e.effort ?? e.reasoning_effort).filter(e => typeof e === 'string' && /^[a-z0-9_-]{1,64}$/.test(e));
+    const rawTiers = raw.service_tiers ?? raw.serviceTiers;
+    const tiers = Array.isArray(rawTiers) ? rawTiers.flatMap(t => {
+      const id = typeof t === 'string' ? t : t.id;
+      return typeof id === 'string' && /^[a-z0-9_-]{1,64}$/.test(id) ? [speed(id)] : [];
+    }) : known?.tiers ?? [speed('default')];
+    if (!tiers.some(t => t.id === 'default')) tiers.unshift(speed('default'));
+    return [{ id, name: raw.display_name ?? known?.name ?? id,
+      contextWindow: positive(raw.context_window) ? raw.context_window : known?.contextWindow ?? 32000,
+      maxTokens: positive(raw.max_output_tokens) ? raw.max_output_tokens : known?.maxTokens ?? 8192,
+      inputModalities: Array.isArray(raw.input_modalities) ? raw.input_modalities.filter(m => ['text','image'].includes(m)) : known?.inputModalities ?? ['text'],
+      efforts: [...new Set(efforts)], defaultEffort: raw.default_reasoning_level ?? known?.defaultEffort ?? efforts[0], tiers }];
+  });
+}
+export function resolveSpeed(model, requested = 'default') {
+  const canonical = requested === 'standard' ? 'default' : requested;
+  const tier = model.tiers.find(t => t.id === canonical) ?? (canonical === 'fast' ? model.tiers.find(t => t.id === 'priority') : undefined);
+  if (!tier) throw new LlmError(`This model does not advertise ${requested} speed; use /speed to inspect available tiers`, 'UNSUPPORTED_SERVICE_TIER');
+  return tier.id;
+}
+export class OpenAIModels {
+  constructor(auth, fetcher = globalThis.fetch) { this.auth = auth; this.fetch = fetcher; this.clear(); }
+  clear() { this.entries = FALLBACK_MODELS; this.checked = 0; this.key = undefined; this.discovered = false; this.error = undefined; }
+  async list(force = false, credential, signal) {
+    let auth = credential;
+    try { auth ??= await this.auth.acquire(signal); }
+    catch (error) { if (signal?.aborted) throw error; this.clear(); this.error = error.message; return this.entries; }
+    if (auth.key !== this.key) { this.clear(); this.key = auth.key; }
+    if (!force && Date.now() - this.checked < 300000) return this.entries;
+    try {
+      const entries = parseModels(await jsonRequest(API + '/models', { headers: { authorization: 'Bearer ' + auth.token }, signal }, this.fetch));
+      if (this.key === auth.key) { this.entries = entries; this.discovered = true; this.error = undefined; }
+      return entries;
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      if (this.key === auth.key) this.error = error.message;
+      return this.key === auth.key ? this.entries : FALLBACK_MODELS;
+    } finally { if (this.key === auth.key) this.checked = Date.now(); }
+  }
+  async get(id, auth, signal) {
+    const model = (await this.list(false, auth, signal)).find(m => m.id === id);
+    if (!model) throw new LlmError('Model is not in the OpenAI account catalog; refresh with /openai models', 'MODEL_NOT_FOUND');
+    return model;
+  }
+}