@gajae-code/coding-agent 0.2.4 → 0.3.0

package/src/vim/engine.ts

@@ -858,7 +858,7 @@ export class VimEngine {
 			}
 			case "r": {
 				const replacement = tokens[nextIndex + 1];
-				if (!replacement || replacement.value.length !== 1) {
+				if (replacement?.value.length !== 1) {
 					throw new VimError("Visual replace requires a literal character", opToken);
 				}
 				const visual = expandVisualOffsets(
@@ -1109,7 +1109,7 @@ export class VimEngine {
 				return nextIndex + 1;
 			case "r": {
 				const replacement = tokens[nextIndex + 1];
-				if (!replacement || replacement.value.length !== 1) {
+				if (replacement?.value.length !== 1) {
 					throw new VimError("r requires a replacement character", token);
 				}
 				await this.#applyAtomicChange(["r", replacement.value], () => {
@@ -1746,7 +1746,7 @@ export class VimEngine {
 			case "t":
 			case "T": {
 				const searchToken = tokens[index + 1];
-				if (!searchToken || searchToken.value.length !== 1) {
+				if (searchToken?.value.length !== 1) {
 					throw new VimError(`${token.value} requires a literal character`, token);
 				}
 				this.lastCharFind = { char: searchToken.value, mode: token.value as "f" | "F" | "t" | "T" };

package/src/web/search/index.ts

@@ -8,6 +8,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { AuthStorage } from "@gajae-code/ai";
 import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
+import { parseModelString } from "../../config/model-resolver";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { type: "text" };
@@ -16,7 +17,7 @@ import { discoverAuthStorage } from "../../sdk";
 import type { ToolSession } from "../../tools";
 import { formatAge } from "../../tools/render-utils";
 import { throwIfAborted } from "../../tools/tool-errors";
-import { getSearchProvider, getSearchProviderLabel, resolveProviderChain, type SearchProvider } from "./provider";
+import { getSearchProviderLabel, resolveProviderChain, type SearchProvider } from "./provider";
 import { renderSearchCall, renderSearchResult, type SearchRenderDetails } from "./render";
 import type { SearchProviderId, SearchResponse } from "./types";
 import { SearchProviderError } from "./types";
@@ -115,10 +116,21 @@ function formatForLLM(response: SearchResponse): string {
 	return parts.join("\n");
 }
 
+/** Best-effort active model provider: prefer the resolved Model, fall back to parsing the model string. */
+function resolveActiveModelProvider(
+	modelProvider: string | undefined,
+	modelString: string | undefined,
+): string | undefined {
+	if (modelProvider) return modelProvider;
+	if (modelString) return parseModelString(modelString)?.provider;
+	return undefined;
+}
+
 interface ExecuteSearchOptions {
 	authStorage: AuthStorage;
 	sessionId?: string;
 	signal?: AbortSignal;
+	activeModelProvider?: string;
 }
 
 /** Execute web search */
@@ -127,20 +139,11 @@ async function executeSearch(
 	params: SearchQueryParams,
 	options: ExecuteSearchOptions,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
-	const { authStorage, sessionId, signal } = options;
-	const providers =
-		params.provider && params.provider !== "auto"
-			? await getSearchProvider(params.provider).then(async provider =>
-					(await provider.isAvailable(authStorage)) ? [provider] : resolveProviderChain(authStorage, "auto"),
-				)
-			: await resolveProviderChain(authStorage);
-	if (providers.length === 0) {
-		const message = "No web search provider configured.";
-		return {
-			content: [{ type: "text" as const, text: `Error: ${message}` }],
-			details: { response: { provider: "none", sources: [] }, error: message },
-		};
-	}
+	const { authStorage, sessionId, signal, activeModelProvider } = options;
+	// Pass `params.provider` straight through: when omitted (the normal model-facing
+	// path) it is `undefined`, so `resolveProviderChain` applies the settings-configured
+	// preferred provider. Coalescing to "auto" here would silently bypass that preference.
+	const providers = await resolveProviderChain(authStorage, params.provider, activeModelProvider);
 
 	const failures: Array<{ provider: SearchProvider; error: unknown }> = [];
 	let lastProvider = providers[0];
@@ -207,13 +210,14 @@ async function executeSearch(
  */
 export async function runSearchQuery(
 	params: SearchQueryParams,
-	options: { authStorage?: AuthStorage; sessionId?: string; signal?: AbortSignal } = {},
+	options: { authStorage?: AuthStorage; sessionId?: string; signal?: AbortSignal; activeModelProvider?: string } = {},
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
 	const authStorage = options.authStorage ?? (await discoverAuthStorage());
 	return executeSearch("cli-web-search", params, {
 		authStorage,
 		sessionId: options.sessionId,
 		signal: options.signal,
+		activeModelProvider: options.activeModelProvider,
 	});
 }
 
@@ -247,7 +251,11 @@ export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRe
 	): Promise<AgentToolResult<SearchRenderDetails>> {
 		const authStorage = this.#session.authStorage ?? (await discoverAuthStorage());
 		const sessionId = this.#session.getSessionId?.() ?? undefined;
-		return executeSearch(_toolCallId, params, { authStorage, sessionId, signal });
+		const activeModelProvider = resolveActiveModelProvider(
+			this.#session.model?.provider,
+			this.#session.getActiveModelString?.(),
+		);
+		return executeSearch(_toolCallId, params, { authStorage, sessionId, signal, activeModelProvider });
 	}
 }
 
@@ -267,7 +275,12 @@ export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRende
 	) {
 		const authStorage = ctx.modelRegistry?.authStorage ?? (await discoverAuthStorage());
 		const sessionId = ctx.sessionManager.getSessionId();
-		return executeSearch(toolCallId, params, { authStorage, sessionId, signal });
+		return executeSearch(toolCallId, params, {
+			authStorage,
+			sessionId,
+			signal,
+			activeModelProvider: ctx.model?.provider,
+		});
 	},
 
 	renderCall(args: SearchToolParams, options: RenderResultOptions, theme: Theme) {

package/src/web/search/provider.ts

@@ -93,6 +93,11 @@ const PROVIDER_META: Record<SearchProviderId, ProviderMeta> = {
 		label: "SearXNG",
 		load: async () => new (await import("./providers/searxng")).SearXNGProvider(),
 	},
+	duckduckgo: {
+		id: "duckduckgo",
+		label: "DuckDuckGo",
+		load: async () => new (await import("./providers/duckduckgo")).DuckDuckGoProvider(),
+	},
 };
 
 const instanceCache = new Map<SearchProviderId, SearchProvider>();
@@ -119,6 +124,7 @@ export async function getSearchProvider(id: SearchProviderId): Promise<SearchPro
 }
 
 export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
+	"duckduckgo",
 	"tavily",
 	"perplexity",
 	"brave",
@@ -135,6 +141,30 @@ export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"searxng",
 ];
 
+/**
+ * Map an active model's provider string to its own native web-search provider.
+ * Keys are real model provider ids (see packages/ai/src/types.ts KnownProvider);
+ * a few aliases (gemini/kimi) and API strings (openai-responses) are tolerated
+ * defensively. Providers absent from this map (custom/unknown) fall through to
+ * DuckDuckGo.
+ */
+const MODEL_PROVIDER_TO_SEARCH: Record<string, SearchProviderId> = {
+	openai: "codex",
+	"openai-codex": "codex",
+	"openai-responses": "codex",
+	anthropic: "anthropic",
+	google: "gemini",
+	"google-gemini-cli": "gemini",
+	"google-antigravity": "gemini",
+	gemini: "gemini",
+	moonshot: "kimi",
+	"kimi-code": "kimi",
+	kimi: "kimi",
+	zai: "zai",
+	perplexity: "perplexity",
+	synthetic: "synthetic",
+};
+
 /** Preferred provider set via settings (default: auto) */
 let preferredProvId: SearchProviderId | "auto" = "auto";
 
@@ -144,30 +174,45 @@ export function setPreferredSearchProvider(provider: SearchProviderId | "auto"):
 }
 
 /**
- * Determine which providers are configured and currently available.
- * Each candidate is loaded (and its `isAvailable()` called) only as the chain
- * is walked, so unconfigured providers never pay the load cost.
+ * Resolve the ordered provider chain for a search request.
+ *
+ * Resolution is active-model-gated, never credential-scanning:
+ *   1. An explicitly preferred provider (settings) that is available is primary.
+ *   2. Otherwise the active model's own native search is primary, but only when
+ *      that provider's own credentials are present (its `isAvailable()`).
+ *   3. DuckDuckGo (keyless) is always appended as the terminal fallback, so a
+ *      missing primary — or a primary runtime failure — still returns results
+ *      with zero configuration. Keyed standalone providers are never
+ *      auto-selected; they are reachable only via explicit selection (step 1).
  */
 export async function resolveProviderChain(
 	authStorage: AuthStorage,
 	preferredProvider: SearchProviderId | "auto" = preferredProvId,
+	activeModelProvider?: string,
 ): Promise<SearchProvider[]> {
-	const providers: SearchProvider[] = [];
+	const chain: SearchProviderId[] = [];
 
 	if (preferredProvider !== "auto") {
 		const provider = await getSearchProvider(preferredProvider);
 		if (await provider.isAvailable(authStorage)) {
-			providers.push(provider);
+			chain.push(preferredProvider);
 		}
-	}
-
-	for (const id of SEARCH_PROVIDER_ORDER) {
-		if (id === preferredProvider) continue;
-		const provider = await getSearchProvider(id);
-		if (await provider.isAvailable(authStorage)) {
-			providers.push(provider);
+	} else if (activeModelProvider) {
+		const nativeId = MODEL_PROVIDER_TO_SEARCH[activeModelProvider.toLowerCase()];
+		if (nativeId) {
+			const provider = await getSearchProvider(nativeId);
+			if (await provider.isAvailable(authStorage)) {
+				chain.push(nativeId);
+			}
 		}
 	}
 
+	// DuckDuckGo is the permissionless terminal fallback (deduped).
+	if (!chain.includes("duckduckgo")) chain.push("duckduckgo");
+
+	const providers: SearchProvider[] = [];
+	for (const id of chain) {
+		providers.push(await getSearchProvider(id));
+	}
 	return providers;
 }

package/src/web/search/providers/duckduckgo.ts

@@ -0,0 +1,279 @@
+/**
+ * DuckDuckGo Web Search Provider
+ *
+ * Keyless, permissionless web search. Scrapes DuckDuckGo's no-JavaScript HTML
+ * endpoints and maps anchors/snippets into the unified SearchResponse shape
+ * (sources only — DuckDuckGo does not synthesize an answer).
+ *
+ * This is the zero-config default/fallback backend: it requires no API key and
+ * no OAuth, so `isAvailable()` is always true. Because DuckDuckGo applies
+ * anti-bot rate limiting (HTTP 202 / 403 / empty responses) from datacenter and
+ * VPN IPs, the provider is best-effort: it retries with backoff, rotates the
+ * user-agent, and alternates between the `html` and `lite` endpoints. When every
+ * attempt fails it throws a {@link SearchProviderError} rather than returning an
+ * empty success — it never falls through to keyed providers.
+ *
+ * Endpoints:
+ *   https://html.duckduckgo.com/html/  (primary)
+ *   https://lite.duckduckgo.com/lite/  (fallback markup)
+ *
+ * The HTML markup is liable to drift; the parser is deliberately small and is
+ * pinned by fixture-driven tests (see test/tools/web-search-duckduckgo.test.ts).
+ */
+
+import type { AuthStorage } from "@gajae-code/ai";
+
+import type { SearchResponse, SearchSource } from "../../../web/search/types";
+import { SearchProviderError } from "../../../web/search/types";
+import { clampNumResults } from "../utils";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
+import { classifyProviderHttpError, withHardTimeout } from "./utils";
+
+const HTML_ENDPOINT = "https://html.duckduckgo.com/html/";
+const LITE_ENDPOINT = "https://lite.duckduckgo.com/lite/";
+
+const DEFAULT_NUM_RESULTS = 10;
+const MAX_NUM_RESULTS = 20;
+
+/** Endpoint order across retry attempts; rotates markup and user-agent. */
+const ATTEMPTS: Array<"html" | "lite"> = ["html", "lite", "html"];
+
+/** Backoff (ms) applied between attempts. Index 0 is unused (first attempt). */
+const BACKOFF_MS = [0, 400, 800];
+
+/** Realistic desktop user-agents rotated per attempt to dodge naive blocks. */
+const USER_AGENTS = [
+	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+	"Mozilla/5.0 (X11; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0",
+];
+
+/** Map our recency filter to DuckDuckGo's `df` time parameter. */
+const RECENCY_MAP: Record<"day" | "week" | "month" | "year", string> = {
+	day: "d",
+	week: "w",
+	month: "m",
+	year: "y",
+};
+
+interface ParsedResult {
+	title: string;
+	url: string;
+	snippet?: string;
+}
+
+/** Decode a small set of HTML entities without pulling in a DOM library. */
+function decodeEntities(input: string): string {
+	return input
+		.replace(/&amp;/g, "&")
+		.replace(/&lt;/g, "<")
+		.replace(/&gt;/g, ">")
+		.replace(/&quot;/g, '"')
+		.replace(/&#0*39;|&#x0*27;|&apos;/gi, "'")
+		.replace(/&#x0*2f;/gi, "/")
+		.replace(/&#(\d+);/g, (_, dec: string) => String.fromCodePoint(Number(dec)))
+		.replace(/&#x([0-9a-f]+);/gi, (_, hex: string) => String.fromCodePoint(Number.parseInt(hex, 16)))
+		.replace(/&nbsp;/g, " ");
+}
+
+/** Strip tags, decode entities, and collapse whitespace from an HTML fragment. */
+function cleanText(fragment: string): string {
+	return decodeEntities(fragment.replace(/<[^>]+>/g, ""))
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+/**
+ * Resolve a DuckDuckGo result href to the real destination URL. DuckDuckGo wraps
+ * external links in a `/l/?uddg=<encoded>` redirect; `lite` sometimes links
+ * directly. Returns null for unusable or internal links (so ads/redirect shells
+ * are dropped).
+ */
+export function decodeResultUrl(href: string): string | null {
+	let h = decodeEntities(href.trim());
+	if (!h || h.startsWith("#")) return null;
+	if (h.startsWith("//")) h = `https:${h}`;
+	let parsed: URL;
+	try {
+		parsed = new URL(h, "https://duckduckgo.com");
+	} catch {
+		return null;
+	}
+	const uddg = parsed.searchParams.get("uddg");
+	if (uddg) {
+		try {
+			const target = new URL(uddg);
+			if (target.protocol !== "http:" && target.protocol !== "https:") return null;
+			if (target.hostname.endsWith("duckduckgo.com")) return null;
+			return target.toString();
+		} catch {
+			return null;
+		}
+	}
+	// No redirect wrapper: accept only real external http(s) links.
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+	if (parsed.hostname.endsWith("duckduckgo.com")) return null;
+	return parsed.toString();
+}
+
+/** Parse results from the `html.duckduckgo.com/html/` markup. */
+export function parseHtmlResults(html: string): ParsedResult[] {
+	const titleRe = /<a\b[^>]*class="[^"]*\bresult__a\b[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+	const snippetRe = /<a\b[^>]*class="[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
+	const snippets: string[] = [];
+	for (const m of html.matchAll(snippetRe)) snippets.push(cleanText(m[1]));
+
+	const results: ParsedResult[] = [];
+	let idx = 0;
+	for (const m of html.matchAll(titleRe)) {
+		const url = decodeResultUrl(m[1]);
+		const title = cleanText(m[2]);
+		const snippet = snippets[idx];
+		idx++;
+		if (!url || !title) continue;
+		results.push({ title, url, snippet: snippet || undefined });
+	}
+	return results;
+}
+
+/** Parse results from the `lite.duckduckgo.com/lite/` markup. */
+export function parseLiteResults(html: string): ParsedResult[] {
+	const linkRe = /<a\b[^>]*class="[^"]*\bresult-link\b[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+	const snippetRe = /<td\b[^>]*class="[^"]*\bresult-snippet\b[^"]*"[^>]*>([\s\S]*?)<\/td>/gi;
+	const snippets: string[] = [];
+	for (const m of html.matchAll(snippetRe)) snippets.push(cleanText(m[1]));
+
+	const results: ParsedResult[] = [];
+	let idx = 0;
+	for (const m of html.matchAll(linkRe)) {
+		const url = decodeResultUrl(m[1]);
+		const title = cleanText(m[2]);
+		const snippet = snippets[idx];
+		idx++;
+		if (!url || !title) continue;
+		results.push({ title, url, snippet: snippet || undefined });
+	}
+	return results;
+}
+
+function delay(ms: number, signal?: AbortSignal): Promise<void> {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener(
+			"abort",
+			() => {
+				clearTimeout(timer);
+				reject(new DOMException("Aborted", "AbortError"));
+			},
+			{ once: true },
+		);
+	});
+}
+
+/** Fetch one endpoint and parse it. Throws on HTTP error, rate-limit, or empty parse. */
+async function fetchAndParse(
+	endpoint: "html" | "lite",
+	query: string,
+	df: string | undefined,
+	userAgent: string,
+	signal: AbortSignal | undefined,
+): Promise<ParsedResult[]> {
+	const url = endpoint === "html" ? HTML_ENDPOINT : LITE_ENDPOINT;
+	const body = new URLSearchParams({ q: query });
+	if (df) body.set("df", df);
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"User-Agent": userAgent,
+			Accept: "text/html,application/xhtml+xml",
+			"Content-Type": "application/x-www-form-urlencoded",
+			"Accept-Language": "en-US,en;q=0.9",
+		},
+		body,
+		signal: withHardTimeout(signal),
+	});
+
+	// DuckDuckGo signals soft blocks with 202 (which is still response.ok).
+	if (response.status === 202) {
+		throw new SearchProviderError("duckduckgo", "duckduckgo: rate-limited (202)", 202);
+	}
+	if (!response.ok) {
+		const errorText = await response.text();
+		const classified = classifyProviderHttpError("duckduckgo", response.status, errorText);
+		if (classified) throw classified;
+		throw new SearchProviderError("duckduckgo", `DuckDuckGo error (${response.status})`, response.status);
+	}
+
+	const text = await response.text();
+	const parsed = endpoint === "html" ? parseHtmlResults(text) : parseLiteResults(text);
+	if (parsed.length === 0) {
+		throw new SearchProviderError("duckduckgo", "duckduckgo: no parseable results (possible block)");
+	}
+	return parsed;
+}
+
+/** Execute a keyless DuckDuckGo web search with light resilience. */
+export async function searchDuckDuckGo(params: {
+	query: string;
+	num_results?: number;
+	recency?: "day" | "week" | "month" | "year";
+	signal?: AbortSignal;
+}): Promise<SearchResponse> {
+	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
+	const df = params.recency ? RECENCY_MAP[params.recency] : undefined;
+
+	let lastError: unknown;
+	for (let attempt = 0; attempt < ATTEMPTS.length; attempt++) {
+		if (params.signal?.aborted) throw new DOMException("Aborted", "AbortError");
+		if (BACKOFF_MS[attempt] > 0) await delay(BACKOFF_MS[attempt], params.signal);
+
+		const endpoint = ATTEMPTS[attempt];
+		const userAgent = USER_AGENTS[attempt % USER_AGENTS.length];
+		try {
+			const parsed = await fetchAndParse(endpoint, params.query, df, userAgent, params.signal);
+			const sources: SearchSource[] = parsed.slice(0, numResults).map(result => ({
+				title: result.title,
+				url: result.url,
+				snippet: result.snippet,
+			}));
+			return { provider: "duckduckgo", sources };
+		} catch (error) {
+			// A caller cancellation must abort immediately, never silently retry.
+			if (params.signal?.aborted) throw error;
+			lastError = error;
+		}
+	}
+
+	if (lastError instanceof SearchProviderError) throw lastError;
+	throw new SearchProviderError(
+		"duckduckgo",
+		`DuckDuckGo search failed after ${ATTEMPTS.length} attempts${
+			lastError instanceof Error ? `: ${lastError.message}` : ""
+		}`,
+	);
+}
+
+/** Keyless, permissionless web search provider backed by DuckDuckGo. */
+export class DuckDuckGoProvider extends SearchProvider {
+	readonly id = "duckduckgo";
+	readonly label = "DuckDuckGo";
+
+	isAvailable(_authStorage: AuthStorage): boolean {
+		return true;
+	}
+
+	search(params: SearchParams): Promise<SearchResponse> {
+		return searchDuckDuckGo({
+			query: params.query,
+			num_results: params.numSearchResults ?? params.limit,
+			recency: params.recency,
+			signal: params.signal,
+		});
+	}
+}

package/src/web/search/types.ts

@@ -6,6 +6,7 @@
 
 /** Supported web search providers */
 export type SearchProviderId =
+	| "duckduckgo"
 	| "exa"
 	| "brave"
 	| "jina"
@@ -23,6 +24,7 @@ export type SearchProviderId =
 
 export function isSearchProviderId(value: string): value is SearchProviderId {
 	return [
+		"duckduckgo",
 		"exa",
 		"brave",
 		"jina",

package/src/modes/theme/dark.json

@@ -1,95 +0,0 @@
-{
-	"$schema": "https://raw.githubusercontent.com/can1357/gajae-code/main/packages/coding-agent/theme-schema.json",
-	"name": "dark",
-	"vars": {
-		"cyan": "#0088fa",
-		"blue": "#178fb9",
-		"green": "#89d281",
-		"red": "#fc3a4b",
-		"yellow": "#e4c00f",
-		"gray": "#777d88",
-		"dimGray": "#5f6673",
-		"darkGray": "#3d424a",
-		"accent": "#febc38",
-		"selectedBg": "#31363f",
-		"userMsgBg": "#221d1a",
-		"toolPendingBg": "#1d2129",
-		"toolSuccessBg": "#161a1f",
-		"toolErrorBg": "#291d1d",
-		"customMsgBg": "#2a2530"
-	},
-	"colors": {
-		"accent": "accent",
-		"border": "blue",
-		"borderAccent": "cyan",
-		"borderMuted": "darkGray",
-		"success": "green",
-		"error": "red",
-		"warning": "yellow",
-		"muted": "gray",
-		"dim": "dimGray",
-		"text": "",
-		"thinkingText": "gray",
-		"selectedBg": "selectedBg",
-		"userMessageBg": "userMsgBg",
-		"userMessageText": "",
-		"customMessageBg": "customMsgBg",
-		"customMessageText": "",
-		"customMessageLabel": "#b281d6",
-		"toolPendingBg": "toolPendingBg",
-		"toolSuccessBg": "toolSuccessBg",
-		"toolErrorBg": "toolErrorBg",
-		"toolTitle": "",
-		"toolOutput": "gray",
-		"mdHeading": "#febc38",
-		"mdLink": "#0088fa",
-		"mdLinkUrl": "dimGray",
-		"mdCode": "#e5c1ff",
-		"mdCodeBlock": "#9CDCFE",
-		"mdCodeBlockBorder": "darkGray",
-		"mdQuote": "gray",
-		"mdQuoteBorder": "darkGray",
-		"mdHr": "darkGray",
-		"mdListBullet": "accent",
-		"toolDiffAdded": "green",
-		"toolDiffRemoved": "red",
-		"toolDiffContext": "gray",
-		"link": "#0088fa",
-		"syntaxComment": "#6A9955",
-		"syntaxKeyword": "#569CD6",
-		"syntaxFunction": "#DCDCAA",
-		"syntaxVariable": "#9CDCFE",
-		"syntaxString": "#CE9178",
-		"syntaxNumber": "#B5CEA8",
-		"syntaxType": "#4EC9B0",
-		"syntaxOperator": "#D4D4D4",
-		"syntaxPunctuation": "#D4D4D4",
-		"thinkingOff": "darkGray",
-		"thinkingMinimal": "dimGray",
-		"thinkingLow": "#178fb9",
-		"thinkingMedium": "#0088fa",
-		"thinkingHigh": "#b281d6",
-		"thinkingXhigh": "#e5c1ff",
-		"bashMode": "cyan",
-		"statusLineBg": "#121212",
-		"statusLineSep": 244,
-		"statusLineModel": "#d787af",
-		"statusLinePath": "#00afaf",
-		"statusLineGitClean": "#5faf5f",
-		"statusLineGitDirty": "#d7af5f",
-		"statusLineContext": "#8787af",
-		"statusLineSpend": "#5fafaf",
-		"statusLineStaged": 70,
-		"statusLineDirty": 178,
-		"statusLineUntracked": 39,
-		"statusLineOutput": 205,
-		"statusLineCost": 205,
-		"statusLineSubagents": "accent",
-		"pythonMode": "yellow"
-	},
-	"export": {
-		"pageBg": "#18181e",
-		"cardBg": "#1e1e24",
-		"infoBg": "#3c3728"
-	}
-}