mixdog 0.7.18 → 0.8.0

package/src/runtime/agent/orchestrator/providers/openai-ws.mjs

@@ -0,0 +1,136 @@
+/**
+ * OpenAI Direct API — WebSocket transport via Responses API.
+ *
+ * Uses the same `sendViaWebSocket` plumbing as openai-oauth (Codex), with two
+ * differences encoded in the `auth.type === 'openai-direct'` branch inside
+ * openai-oauth-ws.mjs:
+ *   1. Authorization header: Bearer <OPENAI_API_KEY> (no account_id, no
+ *      originator).
+ *   2. Endpoint: wss://api.openai.com/v1/responses.
+ *
+ * The Responses API request body is reused from openai-oauth (`buildRequestBody`)
+ * so prompt_cache_key, reasoning effort, and tool wiring stay byte-identical
+ * across the two providers — only the transport endpoint and auth header change.
+ */
+import { sendViaWebSocket } from './openai-oauth-ws.mjs';
+import { buildRequestBody } from './openai-oauth.mjs';
+import { enrichModels } from './model-catalog.mjs';
+import {
+    resolveProviderCacheKey,
+    resolveProviderPromptCacheLane,
+} from '../smart-bridge/cache-strategy.mjs';
+
+const OPENAI_DIRECT_PRIORITY_MODEL_PATTERNS = Object.freeze([
+    /^gpt-5\.5(?:-\d{4}|$)/,
+    /^gpt-5\.4(?:-\d{4}|$)/,
+    /^gpt-5\.4-mini(?:-\d{4}|$)/,
+]);
+
+export function openAiDirectSupportsPriority(model) {
+    const id = String(model || '').trim();
+    return OPENAI_DIRECT_PRIORITY_MODEL_PATTERNS.some(re => re.test(id));
+}
+
+export function applyOpenAIDirectFastTier(body, model, opts) {
+    if (opts?.fast === true && openAiDirectSupportsPriority(model)) {
+        body.service_tier = 'priority';
+    }
+    return body;
+}
+
+export class OpenAIDirectProvider {
+    // input_tokens INCLUDES cached tokens (OpenAI convention). See registry.mjs.
+    static inputExcludesCache = false;
+    name = 'openai';
+    config;
+    constructor(config) {
+        this.config = config || {};
+    }
+    _ensureKey() {
+        const k = this.config.apiKey;
+        if (!k) throw new Error('OPENAI_API_KEY not configured (providers.openai.apiKey)');
+        return k;
+    }
+    async send(messages, model, tools, sendOpts) {
+        const opts = sendOpts || {};
+        const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
+        const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
+        const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
+        const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
+        const externalSignal = opts.signal || null;
+        const apiKey = this._ensureKey();
+        const useModel = model || 'gpt-5.5';
+        const promptCacheLane = resolveProviderPromptCacheLane('openai', opts, this.config);
+        const body = buildRequestBody(messages, useModel, tools, {
+            ...sendOpts,
+            promptCacheProvider: 'openai',
+            promptCacheLane,
+        });
+        // Public OpenAI API priority support is documented separately from the
+        // Codex OAuth catalog. Keep this provider's service-tier decision local
+        // so gpt-5.4-mini can opt into Priority even when the Codex catalog does
+        // not advertise a Fast tier for its OAuth endpoint.
+        applyOpenAIDirectFastTier(body, useModel, opts);
+        // Public Responses API supports prompt_cache_retention='24h' at no
+        // extra cost (same cached_input_tokens billing as the default 5–10
+        // min in-memory cache). Codex/oauth rejects the parameter, so it's
+        // injected only on the direct path. See openai-oauth.mjs:290-294
+        // for the rationale.
+        body.prompt_cache_retention = '24h';
+        // poolKey MUST be sessionId-only. Falling back to promptCacheKey would
+        // let unrelated raw sessions sharing the same provider-scoped cache
+        // bucket reuse each other's pooled socket and inherit lastResponseId
+        // delta state, producing cross-session prompt corruption.
+        const poolKey  = opts.sessionId || null;
+        // cacheKey (prompt_cache_key) only groups the server-side prefix-cache
+        // shard — safe to share across sessions, unlike the sessionId poolKey
+        // above. buildRequestBody derives it from the base namespace plus a
+        // model/system/tools hash, mirroring the Codex OAuth path while keeping
+        // public OpenAI's 24h retention below.
+        const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai');
+        const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
+        const auth = { type: 'openai-direct', apiKey };
+        return sendViaWebSocket({
+            auth,
+            body,
+            sendOpts: opts,
+            onStreamDelta,
+            onToolCall,
+            onTextDelta,
+            onStageChange,
+            externalSignal,
+            poolKey,
+            cacheKey,
+            iteration,
+            useModel,
+            displayModel: (id) => id,
+        });
+    }
+    async listModels() {
+        try {
+            const apiKey = this._ensureKey();
+            const res = await fetch('https://api.openai.com/v1/models', {
+                signal: AbortSignal.timeout(10_000),
+                headers: { 'Authorization': `Bearer ${apiKey}` },
+            });
+            if (!res.ok) return [];
+            const j = await res.json();
+            const models = (j.data || []).map((m) => ({
+                id: m.id,
+                name: m.id,
+                provider: 'openai',
+                contextWindow: 0,
+                // Preserve release timestamp from OpenAI so downstream
+                // freshness filters (e.g. setup UI's 6-month coding-model
+                // cutoff) can drop deprecated generations.
+                created: typeof m.created === 'number' ? m.created : null,
+            }));
+            return await enrichModels(models);
+        } catch {
+            return [];
+        }
+    }
+    async isAvailable() {
+        return !!this.config.apiKey;
+    }
+}

package/src/runtime/agent/orchestrator/providers/opencode-go-usage.mjs

@@ -0,0 +1,317 @@
+import { existsSync, readFileSync, mkdirSync } from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import { join } from 'node:path';
+import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+import { getOpenCodeGoAuthCookie } from '../../../shared/config.mjs';
+
+const CACHE_FILE = 'opencode-go-usage-cache.json';
+const LIVE_TTL_MS = 5 * 60_000;
+const STALE_TTL_MS = 60 * 60_000;
+const BASE_URL = 'https://opencode.ai';
+const WORKSPACES_SERVER_ID = 'def39973159c7f0483d8793a822b8dbb10d067e12c65455fcb4608459ba0234f';
+const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143 Safari/537.36';
+const LIMITS_USD = Object.freeze({
+  rolling: { label: '5H', limitUsd: 12 },
+  weekly: { label: '7D', limitUsd: 30 },
+  monthly: { label: 'M', limitUsd: 60 },
+});
+const DISK_JSON_MEMORY_TTL_MS = 1000;
+let diskJsonCache = { at: 0, file: '', value: null };
+
+function num(value, fallback = null) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function round(value, digits = 4) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  const scale = 10 ** digits;
+  return Math.round(n * scale) / scale;
+}
+
+function clean(value) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  return text || null;
+}
+
+function cachePath() {
+  return join(resolvePluginData(), CACHE_FILE);
+}
+
+function readJson(file) {
+  if (diskJsonCache.file === file && Date.now() - diskJsonCache.at < DISK_JSON_MEMORY_TTL_MS) {
+    return diskJsonCache.value;
+  }
+  try {
+    if (!existsSync(file)) return null;
+    const value = JSON.parse(readFileSync(file, 'utf8'));
+    diskJsonCache = { at: Date.now(), file, value };
+    return value;
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, value) {
+  diskJsonCache = { at: Date.now(), file, value };
+  try {
+    mkdirSync(resolvePluginData(), { recursive: true });
+    void fsp.writeFile(file, JSON.stringify(value, null, 2), 'utf8').catch(() => {});
+  } catch {}
+}
+
+function freshSnapshot(snapshot, ttlMs) {
+  const cachedAt = num(snapshot?.cachedAt, 0);
+  if (!cachedAt || Date.now() - cachedAt > ttlMs) return null;
+  return Array.isArray(snapshot?.quotaWindows) && snapshot.quotaWindows.length ? snapshot : null;
+}
+
+function workspaceIdFromConfig(config = {}) {
+  return clean(process.env.OPENCODE_WORKSPACE_ID)
+    || clean(process.env.OPENCODE_GO_WORKSPACE_ID)
+    || clean(process.env.MIXDOG_OPENCODE_WORKSPACE_ID)
+    || clean(config?.providers?.['opencode-go']?.workspaceId)
+    || clean(config?.providers?.['opencode-go']?.workspace_id);
+}
+
+function normalizeCookie(raw) {
+  const value = clean(raw);
+  if (!value) return null;
+  const authMatch = /(?:^|;\s*)auth=([^;]+)/.exec(value);
+  return authMatch ? authMatch[1] : value;
+}
+
+function parseObjectLiteral(text) {
+  const json = String(text || '')
+    .replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)(\s*:)/g, '$1"$2"$3')
+    .replace(/:\s*!0\b/g, ':true')
+    .replace(/:\s*!1\b/g, ':false')
+    .replace(/:\s*null\b/g, ':null');
+  return JSON.parse(json);
+}
+
+function cookieHeader(authCookie) {
+  return `auth=${authCookie}`;
+}
+
+function requestHeaders(authCookie, { accept = 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', referer = BASE_URL } = {}) {
+  return {
+    Accept: accept,
+    Cookie: cookieHeader(authCookie),
+    Origin: BASE_URL,
+    Referer: referer,
+    'User-Agent': USER_AGENT,
+  };
+}
+
+function normalizeWorkspaceId(raw) {
+  const value = clean(raw);
+  if (!value) return null;
+  if (/^wrk_[a-zA-Z0-9]+$/.test(value)) return value;
+  const match = value.match(/wrk_[a-zA-Z0-9]+/);
+  return match ? match[0] : null;
+}
+
+function parseWorkspaceIdsFromJson(value, out = []) {
+  if (!value) return out;
+  if (typeof value === 'string') {
+    if (/^wrk_[a-zA-Z0-9]+$/.test(value) && !out.includes(value)) out.push(value);
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) parseWorkspaceIdsFromJson(item, out);
+    return out;
+  }
+  if (typeof value === 'object') {
+    for (const item of Object.values(value)) parseWorkspaceIdsFromJson(item, out);
+  }
+  return out;
+}
+
+function parseWorkspaceIds(text) {
+  const body = String(text || '');
+  const ids = [];
+  for (const match of body.matchAll(/id\s*:\s*"?(wrk_[a-zA-Z0-9]+)"?/g)) {
+    if (!ids.includes(match[1])) ids.push(match[1]);
+  }
+  if (ids.length) return ids;
+  try {
+    return parseWorkspaceIdsFromJson(JSON.parse(body));
+  } catch {
+    return [];
+  }
+}
+
+function windowFromUsage(kind, raw) {
+  const limit = LIMITS_USD[kind];
+  if (!limit || !raw || typeof raw !== 'object') return null;
+  let usagePercent = num(
+    raw.usagePercent
+      ?? raw.usage_percent
+      ?? raw.usedPercent
+      ?? raw.used_percent
+      ?? raw.percentUsed
+      ?? raw.percent
+      ?? raw.utilizationPercent
+      ?? raw.utilization_percent,
+    null,
+  );
+  if (usagePercent === null) {
+    const used = num(raw.used ?? raw.usage ?? raw.consumed, null);
+    const quota = num(raw.limit ?? raw.total ?? raw.quota ?? raw.max ?? raw.cap, null);
+    if (used !== null && quota > 0) usagePercent = (used / quota) * 100;
+  }
+  if (usagePercent === null) return null;
+  if (usagePercent >= 0 && usagePercent <= 1) usagePercent *= 100;
+  const resetInSec = num(
+    raw.resetInSec
+      ?? raw.resetInSeconds
+      ?? raw.resetSeconds
+      ?? raw.reset_sec
+      ?? raw.reset_in_sec
+      ?? raw.resetsInSec
+      ?? raw.resetsInSeconds
+      ?? raw.resets_in_seconds,
+    null,
+  );
+  const usedUsd = round(limit.limitUsd * Math.max(0, usagePercent) / 100, 4);
+  const remainingUsd = round(Math.max(0, limit.limitUsd - usedUsd), 4);
+  return {
+    label: limit.label,
+    source: 'opencode-go-console',
+    usedPct: round(usagePercent, 2),
+    limitUsd: limit.limitUsd,
+    usedUsd,
+    remainingUsd,
+    ...(resetInSec !== null ? { resetAt: Date.now() + Math.max(0, resetInSec) * 1000 } : {}),
+  };
+}
+
+function parseWindowObject(html, key) {
+  const source = String(html || '');
+  const match = source.match(new RegExp(`${key}\\s*:\\s*(?:\\$R\\[\\d+\\]\\s*=\\s*)?(\\{[^}]+\\})`));
+  if (!match) return null;
+  try {
+    return parseObjectLiteral(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+function parseUsageHtml(html) {
+  const usage = {
+    rolling: parseWindowObject(html, 'rollingUsage'),
+    weekly: parseWindowObject(html, 'weeklyUsage'),
+    monthly: parseWindowObject(html, 'monthlyUsage'),
+  };
+  if (!usage.rolling || !usage.weekly) {
+    try {
+      const json = JSON.parse(String(html || ''));
+      const root = json?.usage || json?.data || json?.result || json?.payload || json;
+      usage.rolling ||= root?.rollingUsage || root?.rolling || root?.rolling_usage || null;
+      usage.weekly ||= root?.weeklyUsage || root?.weekly || root?.weekly_usage || null;
+      usage.monthly ||= root?.monthlyUsage || root?.monthly || root?.monthly_usage || null;
+    } catch {}
+  }
+  const quotaWindows = Object.entries(usage)
+    .filter(([, raw]) => raw)
+    .map(([kind, raw]) => windowFromUsage(kind, raw))
+    .filter(Boolean);
+  if (!quotaWindows.length) return null;
+  return {
+    provider: 'opencode-go',
+    source: 'opencode-go-console',
+    quotaWindows,
+    rawKeys: Object.keys(usage).sort(),
+  };
+}
+
+export function readCachedOpenCodeGoUsageSnapshot({ allowStale = true } = {}) {
+  const raw = readJson(cachePath());
+  const snapshot = raw?.snapshot || raw;
+  return freshSnapshot(snapshot, allowStale ? STALE_TTL_MS : LIVE_TTL_MS);
+}
+
+export function openCodeGoUsageConfigStatus(config = {}) {
+  const workspaceId = normalizeWorkspaceId(workspaceIdFromConfig(config));
+  const authCookie = normalizeCookie(getOpenCodeGoAuthCookie());
+  return {
+    workspaceIdSet: Boolean(workspaceId),
+    authCookieSet: Boolean(authCookie),
+    ready: Boolean(authCookie),
+  };
+}
+
+async function fetchWorkspaceId(authCookie, { signal } = {}) {
+  const url = new URL(`${BASE_URL}/_server`);
+  url.searchParams.set('id', WORKSPACES_SERVER_ID);
+  const res = await fetch(url, {
+    signal,
+    headers: {
+      ...requestHeaders(authCookie, {
+        accept: 'text/javascript, application/json;q=0.9, */*;q=0.8',
+        referer: BASE_URL,
+      }),
+      'X-Server-Id': WORKSPACES_SERVER_ID,
+      'X-Server-Instance': `server-fn:${Date.now().toString(36)}`,
+    },
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    const err = new Error(res.status === 401 || res.status === 403
+      ? 'OpenCode Go console auth failed'
+      : `OpenCode Go workspace lookup failed (${res.status})`);
+    err.code = res.status === 401 || res.status === 403 ? 'OPENCODE_GO_USAGE_AUTH_FAILED' : 'OPENCODE_GO_USAGE_FETCH_FAILED';
+    throw err;
+  }
+  const [workspaceId] = parseWorkspaceIds(text);
+  if (!workspaceId) {
+    const err = new Error('OpenCode Go workspace id was not found');
+    err.code = 'OPENCODE_GO_USAGE_WORKSPACE_NOT_FOUND';
+    throw err;
+  }
+  return workspaceId;
+}
+
+export async function fetchOpenCodeGoUsageSnapshot(config = {}, { force = false } = {}) {
+  if (!force) {
+    const fresh = readCachedOpenCodeGoUsageSnapshot({ allowStale: false });
+    if (fresh) return fresh;
+  }
+  let workspaceId = normalizeWorkspaceId(workspaceIdFromConfig(config));
+  const authCookie = normalizeCookie(getOpenCodeGoAuthCookie());
+  if (!authCookie) {
+    const err = new Error('OpenCode Go console usage requires auth cookie');
+    err.code = 'OPENCODE_GO_USAGE_AUTH_REQUIRED';
+    throw err;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 6500);
+  try {
+    workspaceId ||= await fetchWorkspaceId(authCookie, { signal: controller.signal });
+    const res = await fetch(`${BASE_URL}/workspace/${encodeURIComponent(workspaceId)}/go`, {
+      signal: controller.signal,
+      headers: requestHeaders(authCookie, { referer: `${BASE_URL}/workspace/${workspaceId}` }),
+    });
+    if (!res.ok) {
+      const err = new Error(res.status === 401 || res.status === 403
+        ? 'OpenCode Go console auth failed'
+        : `OpenCode Go console usage fetch failed (${res.status})`);
+      err.code = res.status === 401 || res.status === 403 ? 'OPENCODE_GO_USAGE_AUTH_FAILED' : 'OPENCODE_GO_USAGE_FETCH_FAILED';
+      throw err;
+    }
+    const html = await res.text();
+    const parsed = parseUsageHtml(html);
+    if (!parsed) {
+      const err = new Error('OpenCode Go console usage data was not found');
+      err.code = 'OPENCODE_GO_USAGE_PARSE_FAILED';
+      throw err;
+    }
+    const snapshot = { ...parsed, workspaceId, cachedAt: Date.now() };
+    writeJson(cachePath(), { version: 1, updatedAt: Date.now(), snapshot });
+    return snapshot;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/runtime/agent/orchestrator/providers/opencode-go.mjs

@@ -0,0 +1,109 @@
+import { AnthropicProvider } from './anthropic.mjs';
+import { OpenAICompatProvider, OPENAI_COMPAT_PRESETS } from './openai-compat.mjs';
+import { getModelMetadataSync } from './model-catalog.mjs';
+
+// OpenCode Go publishes both OpenAI-compatible and Anthropic-compatible
+// endpoints. Route by model family so the CLI matches the official surface
+// instead of forcing every model through /chat/completions.
+const ANTHROPIC_MODEL_PREFIXES = [
+    'minimax-',
+    'qwen',
+];
+
+const OPENCODE_GO_CONTEXT_WINDOWS = Object.freeze({
+    // OpenCode models catalog fixture / models.dev opencode-go provider rows.
+    'minimax-m2.7': 204800,
+    'minimax-m2-7': 204800,
+    'kimi-k2.5': 262144,
+    'kimi-k2-5': 262144,
+    'mimo-v2.5-pro': 1048576,
+    'glm-5': 202752,
+});
+
+function isAnthropicGoModel(model) {
+    const id = String(model || '').toLowerCase();
+    return ANTHROPIC_MODEL_PREFIXES.some(prefix => id.startsWith(prefix));
+}
+
+function opencodeGoContextWindow(_modelId, current = 0) {
+    const native = Number(current);
+    if (Number.isFinite(native) && native > 0) return native;
+    const fallback = OPENCODE_GO_CONTEXT_WINDOWS[String(_modelId || '').toLowerCase()];
+    if (fallback) return fallback;
+    const catalog = getModelMetadataSync(_modelId, 'opencode-go');
+    const contextWindow = Number(catalog?.contextWindow);
+    if (Number.isFinite(contextWindow) && contextWindow > 0) return Math.floor(contextWindow);
+    return 0;
+}
+
+function opencodeGoReasoningLevels(model, current = null) {
+    if (Array.isArray(current) && current.length > 0) return current;
+    const effort = (model?.reasoningOptions || []).find((option) => option?.type === 'effort');
+    if (Array.isArray(effort?.values)) return effort.values.map((value) => String(value || '').trim()).filter(Boolean);
+    return [];
+}
+
+export class OpenCodeGoProvider {
+    static inputExcludesCache = false;
+    name = 'opencode-go';
+    openai;
+    anthropic;
+
+    constructor(config = {}) {
+        const preset = OPENAI_COMPAT_PRESETS['opencode-go'];
+        const baseURL = config.baseURL || preset.baseURL;
+        this.openai = new OpenAICompatProvider('opencode-go', { ...config, baseURL });
+        this.anthropic = new AnthropicProvider({
+            ...config,
+            name: 'opencode-go',
+            baseURL,
+            disableBetaHeaders: true,
+        });
+    }
+
+    async send(messages, model, tools, sendOpts) {
+        if (isAnthropicGoModel(model)) {
+            return this.anthropic.send(messages, model, tools, {
+                ...(sendOpts || {}),
+                cacheStrategy: {
+                    tools: 'none',
+                    system: 'none',
+                    tier3: 'none',
+                    messages: 'none',
+                },
+            });
+        }
+        return this.openai.send(messages, model, tools, sendOpts);
+    }
+
+    async listModels() {
+        const models = await this.openai.listModels();
+        return Array.isArray(models)
+            ? models.map((model) => ({
+                ...model,
+                contextWindow: opencodeGoContextWindow(model?.id, model?.contextWindow),
+                reasoningLevels: opencodeGoReasoningLevels(model, model?.reasoningLevels),
+            }))
+            : models;
+    }
+
+    getCachedModelInfo(model) {
+        const inner = isAnthropicGoModel(model) ? this.anthropic : this.openai;
+        const cached = typeof inner.getCachedModelInfo === 'function'
+            ? inner.getCachedModelInfo(model)
+            : null;
+        const catalog = getModelMetadataSync(model, 'opencode-go');
+        const info = cached || catalog || null;
+        if (!info) {
+            return null;
+        }
+        const contextWindow = opencodeGoContextWindow(model, info.contextWindow);
+        return {
+            ...info,
+            id: info.id || model,
+            provider: this.name,
+            contextWindow: contextWindow || info.contextWindow || null,
+            reasoningLevels: opencodeGoReasoningLevels(info, info.reasoningLevels),
+        };
+    }
+}