mixdog 1.0.10 → 1.0.11

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -22,9 +22,12 @@ import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { loadAnthropic, _normalizeAnthropicModel, _setApiKeyCatalogMirror } from './anthropic-messages.mjs';
 import { ANTHROPIC_VERSION, MODELS } from './lib/anthropic-models.mjs';
 import { streamCallbacks } from './lib/send-callbacks.mjs';
+import { preparePdfTextForProvider } from './media-normalization.mjs';
 export { _test, _toAnthropicMessagesForTest } from './anthropic-messages.mjs';
 
 export class AnthropicProvider {
+  // Takes a PDF as a native document block (decided by this adapter's wire protocol).
+  nativePdf = true;
   // Anthropic reports usage.input_tokens EXCLUDING cache_read/cache_creation
   // (those are separate fields), so the live context-window footprint must
   // add cache_read back. See providerInputExcludesCache() in registry.mjs.
@@ -77,6 +80,9 @@ export class AnthropicProvider {
     // dispatch with an aborted-mid-flight tool_use would otherwise hit
     // the provider as a hard 400 (`tool_use ids ... without tool_result`).
     messages = sanitizeToolPairs(messages);
+    // The flag alone decides: an instance that takes no native PDF (a custom
+    // gateway, OpenCode Go's Anthropic route) gets the PDF as text.
+    messages = await preparePdfTextForProvider(messages, this);
     try {
       return await this._doSend(messages, model, tools, sendOpts);
     } catch (err) {

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-login.mjs

@@ -11,6 +11,7 @@ import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
+import { OAUTH_PAGE_CONTENT_TYPE, oauthErrorHtml, oauthSuccessHtml } from './lib/oauth-page.mjs';
 import {
   AUTH_URL,
   CALLBACK_HOST,
@@ -34,9 +35,10 @@ import {
 } from './antigravity-oauth-tokens.mjs';
 
 const ONBOARD_INTERVAL_MS = 1_000;
-const CALLBACK_FAILURE_HTML =
-  '<html><body><h2>Antigravity sign-in was not completed.</h2>' +
-  '<p>Return to Mixdog for the error details and any account verification link.</p></body></html>';
+const CALLBACK_FAILURE_HTML = oauthErrorHtml(
+  'Antigravity sign-in was not completed.',
+  'Return to Mixdog for the error details and any account verification link.'
+);
 
 function extractProjectId(payload) {
   return typeof payload?.cloudaicompanionProject === 'string' ? payload.cloudaicompanionProject : '';
@@ -353,7 +355,7 @@ export async function beginOAuthLogin({
       const authorizationError = requestUrl.searchParams.get('error');
       if (authorizationError) {
         const detail = requestUrl.searchParams.get('error_description') || authorizationError;
-        res.writeHead(400, { 'Content-Type': 'text/html' });
+        res.writeHead(400, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
         res.end(CALLBACK_FAILURE_HTML);
         // A late denial must not cancel an already accepted code.
         if (!exchangePromise) {
@@ -369,12 +371,12 @@ export async function beginOAuthLogin({
       }
       try {
         await acceptCode(code);
-        res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end('<html><body><h2>Antigravity connected.</h2><p>You can close this tab.</p></body></html>');
+        res.writeHead(200, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
+        res.end(oauthSuccessHtml('Antigravity'));
       } catch {
         // The shared exchange reports its error through waitForCallback.
         // Do not interpolate provider-controlled text into browser HTML.
-        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.writeHead(500, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
         res.end(CALLBACK_FAILURE_HTML);
       }
     });

package/src/runtime/agent/orchestrator/providers/antigravity-oauth.mjs

@@ -63,6 +63,8 @@ async function storedAuth(options) {
 }
 
 export class AntigravityOAuthProvider {
+  // Takes a PDF as a native document block (decided by this adapter's wire protocol).
+  nativePdf = true;
   // usageMetadata.promptTokenCount is the total, cached tokens included.
   static inputExcludesCache = false;
   name = 'antigravity-oauth';

package/src/runtime/agent/orchestrator/providers/antigravity-request.mjs

@@ -1,6 +1,6 @@
 import { randomUUID, createHash } from 'node:crypto';
 import { createProviderReplay, providerReplayItems } from './lib/provider-replay.mjs';
-import { toGeminiContents, toGeminiTools, toGeminiToolConfig } from './gemini-schema.mjs';
+import { toGeminiContents, toGeminiRequestTools, toGeminiToolConfig } from './gemini-schema.mjs';
 import { geminiThinkingConfig } from './gemini-thinking.mjs';
 
 const THOUGHT_SIGNATURE_SENTINEL = 'skip_thought_signature_validator';
@@ -105,8 +105,9 @@ export function buildAntigravityRequest(messages, model, tools, opts = {}, proje
   };
   const request = { contents };
   if (systemText) request.systemInstruction = { role: 'user', parts: [{ text: systemText }] };
+  const requestTools = toGeminiRequestTools(tools, opts.nativeTools);
+  if (requestTools.length) request.tools = requestTools;
   if (tools?.length) {
-    request.tools = [toGeminiTools(tools)];
     request.toolConfig = toGeminiToolConfig(opts.toolChoice) || {
       functionCallingConfig: { mode: antigravityFunctionCallingMode() },
     };

package/src/runtime/agent/orchestrator/providers/auto-effort.mjs

@@ -0,0 +1,77 @@
+// Auto effort: turns the effort judge's difficulty distribution into this
+// turn's effort by moving along the model's effort ladder from a base effort.
+// Every turn starts again from the base, so a run of hard turns never
+// ratchets the effort upward.
+//
+// The base is `medium` on every model: raised only when the request needs it,
+// lowered when it is easy. The ladder is the model's supported efforts from
+// `low` up to the tier below the top: `none`/`minimal` switch thinking off and
+// `max`/`ultra` are reserved for an explicit user choice, so auto never picks
+// them. A chosen `max`/`ultra` is left untouched.
+
+const EFFORT_ORDER = Object.freeze(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const FLOOR_INDEX = EFFORT_ORDER.indexOf('low');
+const RESERVED_TOP = new Set(['max', 'ultra']);
+
+export const AUTO_EFFORT_BASE = 'medium';
+
+/** The effort auto moves from: `medium`, unless the user chose `max`/`ultra`. */
+export function autoEffortBase(chosen) {
+  const effort = String(chosen ?? '')
+    .trim()
+    .toLowerCase();
+  return RESERVED_TOP.has(effort) ? effort : AUTO_EFFORT_BASE;
+}
+
+export const AUTO_EFFORT_MODES = Object.freeze(['off', 'observe', 'on']);
+
+// Below this top-class probability the judge is unsure and the default stays.
+export const AUTO_EFFORT_MIN_CONFIDENCE = 0.4;
+// xhigh costs far more than high, so "very hard" needs a firmer judge;
+// below this it is treated as "hard". 0.65 minimised the eval cost with a
+// false xhigh weighted three times a missed one.
+export const AUTO_EFFORT_VERY_HARD_CONFIDENCE = 0.65;
+
+// The judge rates four levels, each one ladder step from the base: easy -1
+// (low), normal 0 (medium), hard +1 (high), very hard +2 (xhigh).
+export const AUTO_EFFORT_LEVELS = Object.freeze(['easy', 'normal', 'hard', 'very hard']);
+const STEP_OF_LEVEL = [-1, 0, 1, 2];
+
+export function normalizeAutoEffortMode(value) {
+  const mode = String(value ?? '')
+    .trim()
+    .toLowerCase();
+  return AUTO_EFFORT_MODES.includes(mode) ? mode : 'off';
+}
+
+/** The efforts auto may choose for a model, in ascending order. */
+export function autoEffortLadder(options) {
+  const supported = new Set((options || []).map((value) => String(value).trim().toLowerCase()));
+  return EFFORT_ORDER.filter(
+    (level, index) => supported.has(level) && index >= FLOOR_INDEX && !RESERVED_TOP.has(level)
+  );
+}
+
+/** Ladder step for a judge distribution over the four levels (index 0 = easy). */
+export function judgedStep(probs) {
+  const values = Array.isArray(probs) && probs.length === AUTO_EFFORT_LEVELS.length ? probs.map(Number) : null;
+  if (!values || values.some((value) => !Number.isFinite(value))) return { step: 0, level: null, confidence: 0 };
+  const confidence = Math.max(...values);
+  if (confidence < AUTO_EFFORT_MIN_CONFIDENCE) return { step: 0, level: null, confidence };
+  let level = values.indexOf(confidence);
+  if (level === 3 && confidence < AUTO_EFFORT_VERY_HARD_CONFIDENCE) level = 2;
+  return { step: STEP_OF_LEVEL[level], level, confidence };
+}
+
+/**
+ * This turn's effort, or null when auto does not apply (the default lies
+ * outside the ladder). `effort === base` when the judge keeps the default.
+ */
+export function resolveAutoEffort({ base, options, probs }) {
+  const ladder = autoEffortLadder(options);
+  const at = ladder.indexOf(String(base ?? '').toLowerCase());
+  if (at < 0) return null;
+  const { step, level, confidence } = judgedStep(probs);
+  const effort = ladder[Math.max(0, Math.min(ladder.length - 1, at + step))];
+  return { base: ladder[at], effort, step, level, confidence: Number(confidence.toFixed(3)) };
+}

package/src/runtime/agent/orchestrator/providers/cursor.mjs

@@ -7,6 +7,7 @@ import {
   toOpenAIMessages,
   toOpenAITools,
 } from './openai-compat-wire.mjs';
+import { preparePdfTextForProvider } from './media-normalization.mjs';
 import { consumeCompatChatCompletionStream } from './openai-compat-stream.mjs';
 import { ensureChatToolPairs } from './lib/wire-pairing.mjs';
 import { cursorTokenExpiry, exchangeCursorToken, resolveCursorOAuthAccessToken } from './cursor-auth.mjs';
@@ -28,10 +29,10 @@ async function loadCursorRuntime() {
   return runtimePromise;
 }
 
-function toCursorMessages(messages, providerName) {
+function toCursorMessages(messages, providerName, { nativePdf } = {}) {
   const output = [];
   for (const message of messages || []) {
-    const converted = toOpenAIMessages([message], providerName);
+    const converted = toOpenAIMessages([message], providerName, { nativePdf });
     if (message?.role !== 'tool') {
       output.push(...converted);
       continue;
@@ -544,6 +545,9 @@ function selectCursorVariant(group, { effort = null, fast = false } = {}) {
 }
 
 class CursorProviderBase {
+  // Cursor's chat wire has no document block: PDFs lower to text.
+  nativePdf = false;
+
   static inputExcludesCache = false;
   name;
   config;
@@ -614,7 +618,7 @@ class CursorProviderBase {
       // Wire-level pairing guard: a call whose result never committed
       // (cancel/abort) is hard-rejected unpaired, so synthesize the
       // missing tool messages on the assembled array.
-      messages: ensureChatToolPairs(toCursorMessages(messages, this.name)),
+      messages: ensureChatToolPairs(toCursorMessages(messages, this.name, { nativePdf: this.nativePdf })),
       mixdog_session_id: sessionScope,
       stream: true,
       stream_options: { include_usage: true },
@@ -690,10 +694,12 @@ class CursorProviderBase {
       sendOpts.sessionId || sendOpts.providerCacheKey || sendOpts.promptCacheKey || `cursor-call:${randomUUID()}`
     );
     const openAiTools = tools?.length ? toOpenAITools(tools) : undefined;
-    const dispatch = () => {
+    const dispatch = async () => {
       noteRequestServiceTier(cursorSelectionIsFast(cursorSelection) ? 'fast' : '');
+      // Every attempt (retries included) prepares right before it lowers.
+      const prepared = await preparePdfTextForProvider(messages, this);
       return this._dispatchChat(
-        this._chatBody(messages, { cursorSelection, sessionScope, openAiTools, toolChoice: sendOpts.toolChoice }),
+        this._chatBody(prepared, { cursorSelection, sessionScope, openAiTools, toolChoice: sendOpts.toolChoice }),
         { runtime, accessToken, signal, sendOpts, openAiTools }
       );
     };

package/src/runtime/agent/orchestrator/providers/custom-provider.mjs

@@ -114,7 +114,7 @@ async function discoverAnthropicModels(provider) {
     signal: AbortSignal.timeout(10_000),
     headers: { 'x-api-key': provider.apiKey || '', 'anthropic-version': ANTHROPIC_VERSION },
   });
-  if (!res.ok) throw new Error(`${provider.name} models ${res.status}`);
+  if (!res.ok) throw Object.assign(new Error(`${provider.name} models ${res.status}`), { status: res.status });
   const data = await res.json();
   const items = Array.isArray(data?.data) ? data.data : [];
   return items
@@ -143,6 +143,8 @@ export async function createCustomProvider(id, config) {
     const Custom = withConfiguredModels(AnthropicProvider, discoverAnthropicModels);
     // The Anthropic SDK appends /v1/messages itself; accept a /v1 base URL.
     provider = new Custom({ ...engine, name: providerId, baseURL: cfg.baseURL.replace(/\/v1$/i, '') });
+    // An unknown third-party gateway behind the Anthropic wire: PDFs lower to text.
+    provider.nativePdf = false;
   } else {
     const { OpenAICompatProvider } = await import('./openai-compat.mjs');
     const Base =

package/src/runtime/agent/orchestrator/providers/effort-configuration.mjs

@@ -88,11 +88,13 @@ function validSnapshot(value, provider, model, mode) {
   );
 }
 
-export function prepareTurnEffortConfiguration(session, provider) {
+// `turnEffort` overrides the session's saved effort for this turn only (auto
+// effort); the saved default itself is never changed here.
+export function prepareTurnEffortConfiguration(session, provider, turnEffort) {
   const config = provider?.config || {};
   const opts = { ...config, modelParameters: session.modelParameters || {} };
   const mode = effortConfigurationMode(session.provider, session.model, opts);
-  const effort = normalizedEffort(session.provider, session.model, session.effort);
+  const effort = normalizedEffort(session.provider, session.model, turnEffort ?? session.effort);
   if (!mode || !EFFORTS.has(effort)) return null;
   const first = (session.messages || []).find((message) =>
     validSnapshot(message?.meta?.[META_KEY], session.provider, session.model, mode)

package/src/runtime/agent/orchestrator/providers/gemini-request-body.mjs

@@ -9,7 +9,7 @@
  * gemini-schema.mjs.
  */
 import { geminiThinkingConfig } from './gemini-thinking.mjs';
-import { toGeminiContents, toGeminiNativeTools, toGeminiToolConfig, toGeminiTools } from './gemini-schema.mjs';
+import { toGeminiContents, toGeminiRequestTools, toGeminiToolConfig } from './gemini-schema.mjs';
 
 // Request pieces shared by the cached REST path and the SDK path.
 export function buildGeminiRequest(messages, useModel, tools, opts) {
@@ -29,11 +29,9 @@ export function buildGeminiRequest(messages, useModel, tools, opts) {
   const contents = toGeminiContents(chatMsgs, useModel);
   if (!contents.length) throw new Error('No messages to send');
 
-  const nativeGeminiTools = toGeminiNativeTools(opts.nativeTools);
-  const functionGeminiTools = tools?.length ? [toGeminiTools(tools)] : [];
-  const geminiTools =
-    nativeGeminiTools.length || functionGeminiTools.length ? [...nativeGeminiTools, ...functionGeminiTools] : undefined;
-  const toolConfig = functionGeminiTools.length ? toGeminiToolConfig(opts.toolChoice) : undefined;
+  const requestTools = toGeminiRequestTools(tools, opts.nativeTools);
+  const geminiTools = requestTools.length ? requestTools : undefined;
+  const toolConfig = tools?.length ? toGeminiToolConfig(opts.toolChoice) : undefined;
   return { generationConfig, systemInstruction, contents, geminiTools, toolConfig };
 }
 

package/src/runtime/agent/orchestrator/providers/gemini-schema.mjs

@@ -593,6 +593,13 @@ export function toGeminiNativeTools(nativeTools) {
   return out;
 }
 
+// The request `tools` array: hosted tools first, then one function-declaration
+// entry when function tools are present. Empty when neither is present.
+export function toGeminiRequestTools(tools, nativeTools) {
+  const functionTools = tools?.length ? [toGeminiTools(tools)] : [];
+  return [...toGeminiNativeTools(nativeTools), ...functionTools];
+}
+
 export function collectGeminiGroundingSources(candidate) {
   const out = [];
   const seen = new Set();

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -131,6 +131,8 @@ function throwIfGeminiAborted(signal) {
 }
 
 export class GeminiProvider {
+  // Takes a PDF as a native document block (decided by this adapter's wire protocol).
+  nativePdf = true;
   // promptTokenCount is the total (cachedContentTokenCount is a subset), so
   // input already includes cache. See registry.mjs.
   static inputExcludesCache = false;

package/src/runtime/agent/orchestrator/providers/grok-oauth-login.mjs

@@ -4,6 +4,7 @@ import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
+import { OAUTH_PAGE_CONTENT_TYPE, oauthSuccessHtml } from './lib/oauth-page.mjs';
 import {
   CLIENT_ID,
   SCOPE,
@@ -119,8 +120,8 @@ export async function beginOAuthLogin() {
         res.end('Invalid');
         return;
       }
-      res.writeHead(200, { 'Content-Type': 'text/html' });
-      res.end('<html><body><h2>Grok login successful! You can close this tab.</h2></body></html>');
+      res.writeHead(200, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
+      res.end(oauthSuccessHtml('Grok'));
       try {
         const tokens = await exchangeAuthorizationCode({ discovery, pkce, code });
         finish(tokens);

package/src/runtime/agent/orchestrator/providers/grok-oauth.mjs

@@ -259,6 +259,8 @@ async function ensureLatestGrokModel(provider) {
 let _modelRefreshInFlight = null;
 
 export class GrokOAuthProvider {
+  // No document block on this wire: a PDF is lowered to text before the request is built.
+  nativePdf = false;
   // OpenAI-compatible usage: prompt_tokens includes cached. See registry.mjs.
   static inputExcludesCache = false;
   name = 'grok-oauth';

package/src/runtime/agent/orchestrator/providers/lib/anthropic-image-input.mjs

@@ -2,14 +2,16 @@ import {
   API_IMAGE_MAX_BASE64_SIZE,
   IMAGE_MAX_WIDTH,
   IMAGE_MAX_HEIGHT,
-  imageMetadataText,
   resizeImageBuffer,
+  supersedingImageMetadataText,
 } from '../../tools/builtin/read-image-resize.mjs';
 
+import { isEnvironmentError } from '../../../../shared/environment-error.mjs';
+
 const MAX_INPUT_BASE64_SIZE = Math.ceil((64 * 1024 * 1024) / 3) * 4;
 
 export class AnthropicImagePreparationError extends Error {
-  constructor(path, detail, cause) {
+  constructor(path, detail, cause, failingImageData) {
     super(
       `Anthropic image preparation failed at ${path}: ${detail}. The original image and conversation were not changed.`,
       { cause }
@@ -17,12 +19,28 @@ export class AnthropicImagePreparationError extends Error {
     this.name = 'AnthropicImagePreparationError';
     this.code = 'ANTHROPIC_IMAGE_PREPARATION_FAILED';
     this.status = 400;
+    // Identifies the rejected image for recovery; never part of the message.
+    Object.defineProperty(this, 'failingImageData', { value: failingImageData, enumerable: false });
+  }
+}
+
+// The image may be fine; this machine cannot resize it (broken sharp runtime,
+// out of memory...). Not an image rejection: recovery must not strip anything.
+export class AnthropicImageRuntimeError extends Error {
+  constructor(path, cause) {
+    super(
+      `Anthropic image preparation unavailable at ${path}: image resizing is unavailable; repair the sharp runtime. The original image and conversation were not changed.`,
+      { cause }
+    );
+    this.name = 'AnthropicImageRuntimeError';
+    this.code = 'ANTHROPIC_IMAGE_RUNTIME_UNAVAILABLE';
+    this.status = 400;
   }
 }
 
 // Work on the lowered request, not stored history: this covers attachments,
-// tool results, replayed images, and provider switches alike. Keep the 2000px
-// ceiling independent of image count so crossing 20 images never invalidates
+// tool results, replayed images, and provider switches alike. Keep the
+// IMAGE_MAX_WIDTH x IMAGE_MAX_HEIGHT display box (1568px) independent of image count so crossing 20 images never invalidates
 // an earlier image or changes its cached rendition.
 export async function prepareAnthropicImages(messages, { signal } = {}) {
   if (!Array.isArray(messages)) return messages;
@@ -64,12 +82,16 @@ export async function prepareAnthropicImages(messages, { signal } = {}) {
           { profile: 'anthropic' }
         );
       } catch (error) {
-        throw new AnthropicImagePreparationError(partPath, 'image could not be decoded; reattach a valid image', error);
+        if (isEnvironmentError(error)) throw new AnthropicImageRuntimeError(partPath, error);
+        throw new AnthropicImagePreparationError(
+          partPath,
+          'image could not be decoded; reattach a valid image',
+          error,
+          source.data
+        );
       }
       signal?.throwIfAborted();
-      if (!resized) {
-        throw new AnthropicImagePreparationError(partPath, 'image resizing is unavailable; repair the sharp runtime');
-      }
+      if (!resized) throw new AnthropicImageRuntimeError(partPath);
       const dims = resized.dimensions;
       if (
         !dims?.displayWidth ||
@@ -80,7 +102,9 @@ export async function prepareAnthropicImages(messages, { signal } = {}) {
       ) {
         throw new AnthropicImagePreparationError(
           partPath,
-          'image still exceeds the supported size; use a smaller image'
+          'image still exceeds the supported size; use a smaller image',
+          undefined,
+          source.data
         );
       }
       if (resized.data === source.data && resized.mimeType === source.media_type) {
@@ -89,10 +113,7 @@ export async function prepareAnthropicImages(messages, { signal } = {}) {
       }
       changed = true;
       if (dims.originalWidth !== dims.displayWidth || dims.originalHeight !== dims.displayHeight) {
-        next.push({
-          type: 'text',
-          text: `${imageMetadataText(dims)} These display dimensions supersede any earlier display-size annotation for the following image.`,
-        });
+        next.push({ type: 'text', text: supersedingImageMetadataText(dims) });
       }
       // Cache markers stay attached to the same logical block. No
       // sanitizer or reordering runs after this byte-preparation pass.

package/src/runtime/agent/orchestrator/providers/lib/oauth-page.mjs

@@ -0,0 +1,94 @@
+// Shared browser pages for the loopback OAuth callbacks (success / failure).
+
+const LOGO_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="44 44 168 168" aria-hidden="true">
+  <defs>
+    <linearGradient id="titanium-a" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#ffffff"/><stop offset="50%" stop-color="#94a3b8"/><stop offset="100%" stop-color="#ffffff"/>
+    </linearGradient>
+    <linearGradient id="titanium-b" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#cbd5e1"/><stop offset="50%" stop-color="#475569"/><stop offset="100%" stop-color="#cbd5e1"/>
+    </linearGradient>
+    <linearGradient id="titanium-c" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#94a3b8"/><stop offset="50%" stop-color="#334155"/><stop offset="100%" stop-color="#94a3b8"/>
+    </linearGradient>
+  </defs>
+  <g fill="none" stroke-width="22" stroke-linecap="round">
+    <path d="M116.2 61A68 68 0 0 1 191.9 104.7" stroke="url(#titanium-a)"/>
+    <path d="M116.2 61A68 68 0 0 1 191.9 104.7" transform="rotate(120 128 128)" stroke="url(#titanium-b)"/>
+    <path d="M116.2 61A68 68 0 0 1 191.9 104.7" transform="rotate(240 128 128)" stroke="url(#titanium-c)"/>
+  </g>
+  <polygon points="128,112 133,123 144,128 133,133 128,144 123,133 112,128 123,123" fill="#cbd5e1"/>
+  <circle cx="128" cy="128" r="3.5" fill="#07080b"/>
+  <circle cx="128" cy="128" r="1.5" fill="#ffffff"/>
+</svg>`;
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function renderPage({ heading, message, details }) {
+  const title = escapeHtml(heading);
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${title} · Mixdog</title>
+  <style>
+    * { box-sizing: border-box; }
+    html { color-scheme: dark; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      background: #07080b;
+      color: #f8fafc;
+      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif;
+      text-align: center;
+    }
+    main { width: 100%; max-width: 560px; display: flex; flex-direction: column; align-items: center; }
+    .logo { width: 72px; height: 72px; margin-bottom: 24px; }
+    .logo svg { width: 100%; height: 100%; display: block; }
+    h1 { margin: 0 0 10px; font-size: 28px; line-height: 1.15; font-weight: 650; }
+    p { margin: 0; line-height: 1.7; color: #94a3b8; font-size: 15px; }
+    .details {
+      margin-top: 16px;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+      font-size: 13px;
+      color: #94a3b8;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <div class="logo">${LOGO_SVG}</div>
+    <h1>${title}</h1>
+    <p>${escapeHtml(message)}</p>
+    ${details ? `<div class="details">${escapeHtml(details)}</div>` : ''}
+  </main>
+</body>
+</html>`;
+}
+
+export const OAUTH_PAGE_CONTENT_TYPE = 'text/html; charset=utf-8';
+
+export function oauthSuccessHtml(providerName) {
+  return renderPage({
+    heading: 'Authentication successful',
+    message: `Signed in to ${providerName}. You can close this tab and return to Mixdog.`,
+  });
+}
+
+export function oauthErrorHtml(message, details) {
+  return renderPage({ heading: 'Authentication failed', message, details });
+}