@timurproko/a1 0.1.0 → 0.1.1-dev.10

package/dist/src/foundation/owned-ui-settings/sections.js

@@ -0,0 +1,93 @@
+export const AGENT_SECTION_ID = "agent";
+const BOOLEAN_CHOICES = Object.freeze([true, false]);
+export function buildOwnedUiSettingsSections(input) {
+    const ownedSection = {
+        id: "a1",
+        title: "A1",
+        entries: Object.freeze(input.resolution.settings.map(setting => ({
+            id: setting.declaration.id,
+            label: null,
+            backend: "a1",
+            description: setting.declaration.description,
+            value: setting.value,
+            rawValue: setting.value,
+            editable: true,
+            structured: false,
+            minimum: null,
+            maximum: null,
+            flags: [],
+            choices: setting.declaration.allowedValues,
+            origin: setting.source,
+            application: setting.declaration.application,
+        }))),
+        unavailableReason: null,
+        readOnlyReason: null,
+    };
+    return Object.freeze([ownedSection, agentSection(input.agent)]);
+}
+export function findOwnedUiSettingsEntry(sections, id, backend) {
+    for (const section of sections) {
+        const entry = section.entries.find(candidate => candidate.id === id && candidate.backend === backend);
+        if (entry)
+            return entry;
+    }
+    return null;
+}
+function agentSection(snapshot) {
+    if (snapshot === null) {
+        return frozenSection("Agent settings are unavailable because no agent engine is attached", null, []);
+    }
+    if (snapshot.failure !== null) {
+        return frozenSection(`Agent settings are unavailable: ${snapshot.failure}`, null, []);
+    }
+    if (snapshot.descriptors.length === 0) {
+        return frozenSection("The agent engine reported no settings", null, []);
+    }
+    const entries = snapshot.descriptors.map(descriptor => {
+        const raw = Object.hasOwn(snapshot.values, descriptor.key) ? snapshot.values[descriptor.key] : null;
+        return {
+            id: descriptor.key,
+            label: descriptor.label ?? null,
+            backend: "agent",
+            description: descriptor.description ?? null,
+            value: scalar(raw),
+            rawValue: raw,
+            // A structured value is editable through its own surface rather than a
+            // value menu, so it stays reachable instead of being reported as fixed.
+            editable: snapshot.writeAdvertised && descriptor.writable,
+            structured: descriptor.valueType === "json",
+            minimum: descriptor.minimum ?? null,
+            maximum: descriptor.maximum ?? null,
+            flags: descriptor.flags ?? [],
+            // A boolean is a two-value choice even when the engine names no choices,
+            // so it opens the same menu as any other enumerated setting.
+            choices: descriptor.valueType === "boolean" ? BOOLEAN_CHOICES : choicesOf(descriptor.choices),
+            origin: "engine",
+            application: "engine",
+        };
+    });
+    const readOnlyReason = snapshot.writeAdvertised
+        ? (entries.some(entry => entry.editable)
+            ? null
+            : "The agent engine reports no writable settings")
+        : "The agent engine does not support changing settings from this surface";
+    return {
+        id: AGENT_SECTION_ID,
+        title: "Agent",
+        entries: Object.freeze(entries),
+        unavailableReason: null,
+        readOnlyReason,
+    };
+}
+function frozenSection(unavailableReason, readOnlyReason, entries) {
+    return { id: AGENT_SECTION_ID, title: "Agent", entries: Object.freeze(entries), unavailableReason, readOnlyReason };
+}
+function scalar(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : null;
+}
+function choicesOf(choices) {
+    if (choices === undefined)
+        return null;
+    const scalars = choices.map(scalar).filter((choice) => choice !== null);
+    return scalars.length === choices.length ? Object.freeze(scalars) : null;
+}

package/dist/src/foundation/owned-ui-settings/session.d.ts

@@ -0,0 +1,44 @@
+import type { AgentSettingsPort } from "../agent-engine-contracts/index.js";
+import type { OwnedUiSettingValue } from "./declarations.js";
+import type { OwnedUiSettingsResolution } from "./resolution.js";
+import { type OwnedUiSettingsBackend, type OwnedUiSettingsSection } from "./sections.js";
+import type { OwnedUiSettingsStore } from "./store.js";
+export interface OwnedUiSettingsChangeOutcome {
+    readonly applied: boolean;
+    /** True when the value is stored but only takes effect on the next start. */
+    readonly pendingRestart: boolean;
+    /** Present when the change could not be persisted; the surface must not show it as saved. */
+    readonly failure: string | null;
+}
+export interface OwnedUiSettingsSessionOptions {
+    readonly store: OwnedUiSettingsStore;
+    /** Null when no engine is attached; the Agent section then reports itself unavailable. */
+    readonly agent?: AgentSettingsPort | null;
+    /**
+     * Resolves the port at load time instead of construction time, for an engine
+     * whose runtime is not up yet. Takes precedence over `agent`.
+     */
+    readonly agentProvider?: () => AgentSettingsPort | null;
+}
+export type OwnedUiSettingsListener = (session: OwnedUiSettingsSession) => void;
+/**
+ * Holds the resolved settings for one owned UI session and routes every accepted
+ * change to the backend that owns it: A1 settings to the A1 document, agent
+ * settings to the engine settings port. Neither backend ever sees the other's value.
+ */
+export declare class OwnedUiSettingsSession {
+    #private;
+    constructor(options: OwnedUiSettingsSessionOptions);
+    get resolution(): OwnedUiSettingsResolution;
+    /** Reads the engine's settings so the Agent section can be built. Never throws. */
+    load(): Promise<void>;
+    sections(): readonly OwnedUiSettingsSection[];
+    /** Resolved value of an A1 setting, or null when it is not declared. */
+    value(id: string): OwnedUiSettingValue | null;
+    /** Value stored this session but not yet in effect, for a restart-required setting. */
+    pendingValue(id: string): OwnedUiSettingValue | null;
+    onChange(listener: OwnedUiSettingsListener): () => void;
+    /** Writes a structured value, which only an engine-backed setting can hold. */
+    changeStructured(backend: OwnedUiSettingsBackend, id: string, value: Readonly<Record<string, unknown>>): Promise<OwnedUiSettingsChangeOutcome>;
+    change(backend: OwnedUiSettingsBackend, id: string, value: OwnedUiSettingValue): Promise<OwnedUiSettingsChangeOutcome>;
+}

package/dist/src/foundation/owned-ui-settings/session.js

@@ -0,0 +1,145 @@
+import { buildOwnedUiSettingsSections, findOwnedUiSettingsEntry, } from "./sections.js";
+/**
+ * Holds the resolved settings for one owned UI session and routes every accepted
+ * change to the backend that owns it: A1 settings to the A1 document, agent
+ * settings to the engine settings port. Neither backend ever sees the other's value.
+ */
+export class OwnedUiSettingsSession {
+    #store;
+    #agent;
+    #agentProvider;
+    #listeners = new Set();
+    #resolution;
+    #agentSnapshot = null;
+    #pending = new Map();
+    constructor(options) {
+        this.#store = options.store;
+        this.#agent = options.agent ?? null;
+        this.#agentProvider = options.agentProvider ?? null;
+        this.#resolution = options.store.read();
+    }
+    get resolution() {
+        return this.#resolution;
+    }
+    /** Reads the engine's settings so the Agent section can be built. Never throws. */
+    async load() {
+        this.#resolution = this.#store.read();
+        const agent = this.#agentProvider === null ? this.#agent : this.#agentProvider();
+        this.#agentSnapshot = agent === null ? null : await snapshotOf(agent);
+        this.#notify();
+    }
+    sections() {
+        return buildOwnedUiSettingsSections({ resolution: this.#resolution, agent: this.#agentSnapshot });
+    }
+    /** Resolved value of an A1 setting, or null when it is not declared. */
+    value(id) {
+        return this.#resolution.settings.find(setting => setting.declaration.id === id)?.value ?? null;
+    }
+    /** Value stored this session but not yet in effect, for a restart-required setting. */
+    pendingValue(id) {
+        return this.#pending.get(id) ?? null;
+    }
+    onChange(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    /** Writes a structured value, which only an engine-backed setting can hold. */
+    async changeStructured(backend, id, value) {
+        if (backend !== "agent")
+            return failed("only an agent setting holds a structured value");
+        const agent = this.#agentProvider === null ? this.#agent : this.#agentProvider();
+        if (agent === null)
+            return failed("no agent engine is attached");
+        if (!agent.capabilities.write || !agent.writeSetting) {
+            return failed("the agent engine does not support changing settings from this surface");
+        }
+        try {
+            await agent.writeSetting(id, value);
+            if (agent.capabilities.flush && agent.flush)
+                await agent.flush();
+        }
+        catch (error) {
+            return failed(`${id} could not be written to the agent engine: ${describe(error)}`);
+        }
+        this.#agentSnapshot = await snapshotOf(agent);
+        this.#notify();
+        return { applied: true, pendingRestart: false, failure: null };
+    }
+    async change(backend, id, value) {
+        const entry = findOwnedUiSettingsEntry(this.sections(), id, backend);
+        if (entry === null)
+            return failed(`unknown ${backend} setting: ${id}`);
+        if (!entry.editable)
+            return failed(`${id} is not editable from this surface`);
+        return backend === "a1" ? this.#changeOwned(id, value) : await this.#changeAgent(id, value);
+    }
+    #changeOwned(id, value) {
+        const outcome = this.#store.write(this.#resolution, id, value);
+        if (!outcome.stored)
+            return failed(outcome.failure ?? `${id} could not be stored`);
+        const previous = this.#resolution;
+        this.#resolution = this.#store.read();
+        const declaration = previous.settings.find(setting => setting.declaration.id === id)?.declaration;
+        if (declaration?.application === "restart") {
+            this.#pending.set(id, value);
+            this.#resolution = previous;
+            this.#notify();
+            return { applied: false, pendingRestart: true, failure: null };
+        }
+        this.#pending.delete(id);
+        this.#notify();
+        return { applied: true, pendingRestart: false, failure: null };
+    }
+    async #changeAgent(id, value) {
+        const agent = this.#agentProvider === null ? this.#agent : this.#agentProvider();
+        if (agent === null)
+            return failed("no agent engine is attached");
+        if (!agent.capabilities.write || !agent.writeSetting) {
+            return failed("the agent engine does not support changing settings from this surface");
+        }
+        try {
+            await agent.writeSetting(id, value);
+            if (agent.capabilities.flush && agent.flush)
+                await agent.flush();
+        }
+        catch (error) {
+            return failed(`${id} could not be written to the agent engine: ${describe(error)}`);
+        }
+        this.#agentSnapshot = await snapshotOf(agent);
+        this.#notify();
+        return { applied: true, pendingRestart: false, failure: null };
+    }
+    #notify() {
+        for (const listener of this.#listeners)
+            listener(this);
+    }
+}
+async function snapshotOf(agent) {
+    try {
+        const descriptors = await agent.listSettings();
+        const values = {};
+        for (const descriptor of descriptors) {
+            try {
+                values[descriptor.key] = await agent.readSetting(descriptor.key) ?? null;
+            }
+            catch {
+                values[descriptor.key] = null;
+            }
+        }
+        return {
+            descriptors,
+            values,
+            writeAdvertised: agent.capabilities.write && typeof agent.writeSetting === "function",
+            failure: null,
+        };
+    }
+    catch (error) {
+        return { descriptors: [], values: {}, writeAdvertised: false, failure: describe(error) };
+    }
+}
+function failed(failure) {
+    return { applied: false, pendingRestart: false, failure };
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/foundation/owned-ui-settings/store.d.ts

@@ -0,0 +1,28 @@
+import { type OwnedUiSettingDeclaration, type OwnedUiSettingValue } from "./declarations.js";
+import { type OwnedUiSettingsMigration } from "./migrations.js";
+import { type OwnedUiSettingsResolution } from "./resolution.js";
+export interface OwnedUiSettingsStoreOptions {
+    /** A1 configuration root. Settings live under `<configDir>/settings/`. */
+    readonly configDir: string;
+    readonly profileId: string;
+    readonly declarations?: readonly OwnedUiSettingDeclaration[];
+    readonly migrations?: readonly OwnedUiSettingsMigration[];
+}
+export interface OwnedUiSettingsWriteOutcome {
+    readonly stored: boolean;
+    /** Present when the write failed; the caller must not report the change as saved. */
+    readonly failure: string | null;
+}
+export declare class OwnedUiSettingsStore {
+    #private;
+    constructor(options: OwnedUiSettingsStoreOptions);
+    get file(): string;
+    /** Reads and resolves. Never throws: every failure becomes a notice. */
+    read(): OwnedUiSettingsResolution;
+    /**
+     * Writes the resolved form with `id` set to `value`, preserving undeclared keys.
+     * Atomic: a temporary sibling is renamed over the target, so an interrupted
+     * write leaves either the complete previous document or the complete new one.
+     */
+    write(resolution: OwnedUiSettingsResolution, id: string, value: OwnedUiSettingValue): OwnedUiSettingsWriteOutcome;
+}

package/dist/src/foundation/owned-ui-settings/store.js

@@ -0,0 +1,90 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { OWNED_UI_SETTINGS_VERSION, OWNED_UI_SETTING_DECLARATIONS, } from "./declarations.js";
+import { OWNED_UI_SETTINGS_MIGRATIONS } from "./migrations.js";
+import { documentFrom, parseOwnedUiSettingsDocument, resolveOwnedUiSettings, } from "./resolution.js";
+const PROFILE_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+const MAX_DOCUMENT_BYTES = 256 * 1024;
+export class OwnedUiSettingsStore {
+    #file;
+    #declarations;
+    #migrations;
+    constructor(options) {
+        if (!PROFILE_ID_PATTERN.test(options.profileId)) {
+            throw new Error(`owned UI settings profile id is not a bounded slug: ${options.profileId}`);
+        }
+        this.#file = path.join(path.resolve(options.configDir), "settings", `${options.profileId}.json`);
+        this.#declarations = options.declarations ?? OWNED_UI_SETTING_DECLARATIONS;
+        this.#migrations = options.migrations ?? OWNED_UI_SETTINGS_MIGRATIONS;
+    }
+    get file() {
+        return this.#file;
+    }
+    /** Reads and resolves. Never throws: every failure becomes a notice. */
+    read() {
+        let raw = null;
+        let unreadable = null;
+        try {
+            raw = readFileSync(this.#file, "utf8");
+        }
+        catch (error) {
+            if (!isMissing(error))
+                unreadable = `${this.#file} could not be read: ${describe(error)}`;
+        }
+        if (raw !== null && Buffer.byteLength(raw, "utf8") > MAX_DOCUMENT_BYTES) {
+            unreadable = `${this.#file} exceeds the ${MAX_DOCUMENT_BYTES}-byte settings limit and was ignored`;
+            raw = null;
+        }
+        const document = raw === null ? null : parseOwnedUiSettingsDocument(raw);
+        if (raw !== null && document === null && unreadable === null) {
+            unreadable = `${this.#file} is not a valid settings document and was ignored`;
+        }
+        return resolveOwnedUiSettings({
+            declarations: this.#declarations,
+            migrations: this.#migrations,
+            document,
+            ...(unreadable === null ? {} : { unreadableDetail: unreadable }),
+            currentVersion: OWNED_UI_SETTINGS_VERSION,
+        });
+    }
+    /**
+     * Writes the resolved form with `id` set to `value`, preserving undeclared keys.
+     * Atomic: a temporary sibling is renamed over the target, so an interrupted
+     * write leaves either the complete previous document or the complete new one.
+     */
+    write(resolution, id, value) {
+        const declaration = this.#declarations.find(candidate => candidate.id === id);
+        if (!declaration)
+            return { stored: false, failure: `unknown owned UI setting: ${id}` };
+        if (!declaration.allowedValues.includes(value)) {
+            return { stored: false, failure: `value ${JSON.stringify(value)} is not allowed for ${id}` };
+        }
+        const current = documentFrom(resolution);
+        const next = {
+            version: OWNED_UI_SETTINGS_VERSION,
+            values: { ...current.values, [id]: value },
+        };
+        const temporary = `${this.#file}.${process.pid}.tmp`;
+        try {
+            mkdirSync(path.dirname(this.#file), { recursive: true, mode: 0o700 });
+            writeFileSync(temporary, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+            renameSync(temporary, this.#file);
+            return { stored: true, failure: null };
+        }
+        catch (error) {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch {
+                // A leftover temporary file is inert: read() only ever opens the target path.
+            }
+            return { stored: false, failure: `${this.#file} could not be written: ${describe(error)}` };
+        }
+    }
+}
+function isMissing(error) {
+    return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/foundation/pi-component-adapter/components.d.ts

@@ -2,4 +2,3 @@ import type { OwnedUiTranscriptBlock } from "../owned-ui-contracts/index.js";
 export declare function adaptPiUserMessage(block: OwnedUiTranscriptBlock, width: number): readonly string[];
 export declare function adaptPiAssistantMessage(block: OwnedUiTranscriptBlock, width: number): readonly string[];
 export declare function adaptPiToolExecution(block: OwnedUiTranscriptBlock, width: number, cwd: string): readonly string[];
-//# sourceMappingURL=components.d.ts.map

package/dist/src/foundation/pi-component-adapter/components.js

@@ -62,4 +62,3 @@ function emptyUsage() {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
-//# sourceMappingURL=components.js.map

package/dist/src/foundation/pi-component-adapter/conformance.d.ts

@@ -8,10 +8,10 @@ export interface PiComponentConformanceReport {
     readonly packageVersion: string;
     readonly ownedUiContractVersion: number;
     readonly componentResults: readonly PiComponentConformanceResult[];
+    readonly componentFamilies: readonly string[];
 }
 export declare class PiComponentConformanceError extends Error {
     readonly stage: "theme" | "components";
     constructor(stage: "theme" | "components", cause: unknown);
 }
 export declare function runPiComponentConformance(): Promise<PiComponentConformanceReport>;
-//# sourceMappingURL=conformance.d.ts.map

package/dist/src/foundation/pi-component-adapter/conformance.js

@@ -1,9 +1,10 @@
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { AssistantMessageComponent, initTheme, ToolExecutionComponent, UserMessageComponent, VERSION, } from "@earendil-works/pi-coding-agent";
+import { AssistantMessageComponent, ExtensionSelectorComponent, initTheme, LoginDialogComponent, ModelSelectorComponent, SettingsSelectorComponent, ThemeSelectorComponent, ThinkingSelectorComponent, ToolExecutionComponent, UserMessageComponent, UserMessageSelectorComponent, VERSION, } from "@earendil-works/pi-coding-agent";
 import { OWNED_UI_CONTRACT_VERSION } from "../owned-ui-contracts/index.js";
 import { createTuiFacade, validatedAssistantMessage } from "./shell-components.js";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 export class PiComponentConformanceError extends Error {
     stage;
     constructor(stage, cause) {
@@ -13,7 +14,7 @@ export class PiComponentConformanceError extends Error {
     }
 }
 export async function runPiComponentConformance() {
-    const root = await mkdtemp(join(tmpdir(), "addone-pi-components-"));
+    const root = await mkdtemp(join(tmpdir(), `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}pi-components-`));
     try {
         try {
             initTheme("dark", false);
@@ -23,7 +24,12 @@ export async function runPiComponentConformance() {
         }
         try {
             const width = 80;
-            const user = new UserMessageComponent("hello from AddOne");
+            const publicConstructors = [UserMessageComponent, AssistantMessageComponent, ToolExecutionComponent, ExtensionSelectorComponent,
+                LoginDialogComponent, ModelSelectorComponent, SettingsSelectorComponent, ThemeSelectorComponent, ThinkingSelectorComponent,
+                UserMessageSelectorComponent];
+            if (publicConstructors.some(constructor => typeof constructor !== "function"))
+                throw new Error("a reused public component constructor is missing");
+            const user = new UserMessageComponent(`hello from ${PRODUCT_IDENTITY.displayName}`);
             const assistantBlock = {
                 id: "assistant-1",
                 kind: "assistant",
@@ -48,6 +54,7 @@ export async function runPiComponentConformance() {
                 packageVersion: VERSION,
                 ownedUiContractVersion: OWNED_UI_CONTRACT_VERSION,
                 componentResults,
+                componentFamilies: ["messages", "tool-execution", "selectors", "dialogs", "editor-autocomplete", "footer-status", "extension-surfaces"],
             };
         }
         catch (error) {
@@ -60,4 +67,3 @@ export async function runPiComponentConformance() {
         await rm(root, { recursive: true, force: true });
     }
 }
-//# sourceMappingURL=conformance.js.map

package/dist/src/foundation/pi-component-adapter/index.d.ts

@@ -3,6 +3,7 @@ export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";
 export * from "./upstream/theme/theme-controller.js";
+export { applyConfiguredPiTheme, getAvailablePiThemes } from "./upstream/theme/theme.js";
 export * from "./upstream/components/countdown-timer.js";
 export * from "./upstream/components/extension-editor.js";
 export * from "./upstream/components/session-selector.js";
@@ -10,4 +11,3 @@ export * from "./upstream/components/session-selector-search.js";
 export * from "./upstream/components/status-indicator.js";
 export * from "./upstream/components/tree-selector.js";
 export * from "./upstream/adjacent/core/keybindings.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/foundation/pi-component-adapter/index.js

@@ -3,6 +3,7 @@ export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";
 export * from "./upstream/theme/theme-controller.js";
+export { applyConfiguredPiTheme, getAvailablePiThemes } from "./upstream/theme/theme.js";
 export * from "./upstream/components/countdown-timer.js";
 export * from "./upstream/components/extension-editor.js";
 export * from "./upstream/components/session-selector.js";
@@ -10,4 +11,3 @@ export * from "./upstream/components/session-selector-search.js";
 export * from "./upstream/components/status-indicator.js";
 export * from "./upstream/components/tree-selector.js";
 export * from "./upstream/adjacent/core/keybindings.js";
-//# sourceMappingURL=index.js.map

package/dist/src/foundation/pi-component-adapter/resources/builtin-themes.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Attributed owned theme resources adapted from @earendil-works/pi-coding-agent 0.84.2 (MIT).
+ * Upstream dark.json SHA-256: 113bc1fd556727b165804c18b5d377c14d421b3fdff3909a63736f421d0a3b00
+ * Upstream light.json SHA-256: 893f0d7e8513dbd5e5112982fd6eb65ceb03ae18ed04854ac57803b9c8908fa0
+ * Modifications: removed upstream schema/export metadata; runtime color data is unchanged.
+ */
+export declare const BUILTIN_THEME_RESOURCES: Readonly<{
+    readonly dark: {
+        readonly name: "dark";
+        readonly vars: {
+            readonly cyan: "#00d7ff";
+            readonly blue: "#5f87ff";
+            readonly green: "#b5bd68";
+            readonly red: "#cc6666";
+            readonly yellow: "#ffff00";
+            readonly text: "#d4d4d4";
+            readonly gray: "#808080";
+            readonly dimGray: "#666666";
+            readonly darkGray: "#505050";
+            readonly accent: "#8abeb7";
+            readonly selectedBg: "#3a3a4a";
+            readonly userMsgBg: "#343541";
+            readonly toolPendingBg: "#282832";
+            readonly toolSuccessBg: "#283228";
+            readonly toolErrorBg: "#3c2828";
+            readonly customMsgBg: "#2d2838";
+        };
+        readonly colors: {
+            readonly accent: "accent";
+            readonly border: "blue";
+            readonly borderAccent: "cyan";
+            readonly borderMuted: "darkGray";
+            readonly success: "green";
+            readonly error: "red";
+            readonly warning: "yellow";
+            readonly muted: "gray";
+            readonly dim: "dimGray";
+            readonly text: "text";
+            readonly thinkingText: "gray";
+            readonly selectedBg: "selectedBg";
+            readonly scrollbarThumb: "selectedBg";
+            readonly searchMatchBg: "selectedBg";
+            readonly searchMatchText: "text";
+            readonly userMessageBg: "userMsgBg";
+            readonly userMessageText: "text";
+            readonly customMessageBg: "customMsgBg";
+            readonly customMessageText: "text";
+            readonly customMessageLabel: "#9575cd";
+            readonly toolPendingBg: "toolPendingBg";
+            readonly toolSuccessBg: "toolSuccessBg";
+            readonly toolErrorBg: "toolErrorBg";
+            readonly toolTitle: "text";
+            readonly toolOutput: "gray";
+            readonly mdHeading: "#f0c674";
+            readonly mdLink: "#81a2be";
+            readonly mdLinkUrl: "dimGray";
+            readonly mdCode: "accent";
+            readonly mdCodeBlock: "green";
+            readonly mdCodeBlockBorder: "gray";
+            readonly mdQuote: "gray";
+            readonly mdQuoteBorder: "gray";
+            readonly mdHr: "gray";
+            readonly mdListBullet: "accent";
+            readonly toolDiffAdded: "green";
+            readonly toolDiffRemoved: "red";
+            readonly toolDiffContext: "gray";
+            readonly syntaxComment: "#6A9955";
+            readonly syntaxKeyword: "#569CD6";
+            readonly syntaxFunction: "#DCDCAA";
+            readonly syntaxVariable: "#9CDCFE";
+            readonly syntaxString: "#CE9178";
+            readonly syntaxNumber: "#B5CEA8";
+            readonly syntaxType: "#4EC9B0";
+            readonly syntaxOperator: "#D4D4D4";
+            readonly syntaxPunctuation: "#D4D4D4";
+            readonly thinkingOff: "darkGray";
+            readonly thinkingMinimal: "#6e6e6e";
+            readonly thinkingLow: "#5f87af";
+            readonly thinkingMedium: "#81a2be";
+            readonly thinkingHigh: "#b294bb";
+            readonly thinkingXhigh: "#d183e8";
+            readonly thinkingMax: "#ff5fff";
+            readonly bashMode: "green";
+        };
+    };
+    readonly light: {
+        readonly name: "light";
+        readonly vars: {
+            readonly teal: "#5a8080";
+            readonly blue: "#547da7";
+            readonly green: "#588458";
+            readonly red: "#aa5555";
+            readonly yellow: "#9a7326";
+            readonly text: "#1f2328";
+            readonly mediumGray: "#6c6c6c";
+            readonly dimGray: "#767676";
+            readonly lightGray: "#b0b0b0";
+            readonly selectedBg: "#d0d0e0";
+            readonly userMsgBg: "#e8e8e8";
+            readonly toolPendingBg: "#e8e8f0";
+            readonly toolSuccessBg: "#e8f0e8";
+            readonly toolErrorBg: "#f0e8e8";
+            readonly customMsgBg: "#ede7f6";
+        };
+        readonly colors: {
+            readonly accent: "teal";
+            readonly border: "blue";
+            readonly borderAccent: "teal";
+            readonly borderMuted: "lightGray";
+            readonly success: "green";
+            readonly error: "red";
+            readonly warning: "yellow";
+            readonly muted: "mediumGray";
+            readonly dim: "dimGray";
+            readonly text: "text";
+            readonly thinkingText: "mediumGray";
+            readonly selectedBg: "selectedBg";
+            readonly scrollbarThumb: "selectedBg";
+            readonly searchMatchBg: "selectedBg";
+            readonly searchMatchText: "text";
+            readonly userMessageBg: "userMsgBg";
+            readonly userMessageText: "text";
+            readonly customMessageBg: "customMsgBg";
+            readonly customMessageText: "text";
+            readonly customMessageLabel: "#7e57c2";
+            readonly toolPendingBg: "toolPendingBg";
+            readonly toolSuccessBg: "toolSuccessBg";
+            readonly toolErrorBg: "toolErrorBg";
+            readonly toolTitle: "text";
+            readonly toolOutput: "mediumGray";
+            readonly mdHeading: "yellow";
+            readonly mdLink: "blue";
+            readonly mdLinkUrl: "dimGray";
+            readonly mdCode: "teal";
+            readonly mdCodeBlock: "green";
+            readonly mdCodeBlockBorder: "mediumGray";
+            readonly mdQuote: "mediumGray";
+            readonly mdQuoteBorder: "mediumGray";
+            readonly mdHr: "mediumGray";
+            readonly mdListBullet: "green";
+            readonly toolDiffAdded: "green";
+            readonly toolDiffRemoved: "red";
+            readonly toolDiffContext: "mediumGray";
+            readonly syntaxComment: "#008000";
+            readonly syntaxKeyword: "#0000FF";
+            readonly syntaxFunction: "#795E26";
+            readonly syntaxVariable: "#001080";
+            readonly syntaxString: "#A31515";
+            readonly syntaxNumber: "#098658";
+            readonly syntaxType: "#267F99";
+            readonly syntaxOperator: "#000000";
+            readonly syntaxPunctuation: "#000000";
+            readonly thinkingOff: "lightGray";
+            readonly thinkingMinimal: "#767676";
+            readonly thinkingLow: "blue";
+            readonly thinkingMedium: "teal";
+            readonly thinkingHigh: "#875f87";
+            readonly thinkingXhigh: "#8b008b";
+            readonly thinkingMax: "#af005f";
+            readonly bashMode: "green";
+        };
+    };
+}>;
+export type BuiltinThemeName = keyof typeof BUILTIN_THEME_RESOURCES;
+export declare function isBuiltinThemeName(name: string): name is BuiltinThemeName;