@cogcoin/client 1.0.1 → 1.1.0

package/dist/wallet/mining/control.js

@@ -2,11 +2,14 @@ import { acquireFileLock } from "../fs/lock.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, createWalletSecretReference, } from "../state/provider.js";
 import { loadWalletState } from "../state/storage.js";
+import { isRootDomainName } from "../read/filter.js";
 import { appendMiningEvent, getLastMiningEventTimestamp, loadMiningRuntimeStatus, readMiningEvents, saveMiningRuntimeStatus, followMiningEvents, } from "./runtime-artifacts.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
 import { normalizeMiningPublishState, normalizeMiningStateRecord } from "./state.js";
 import { loadClientConfig, saveBuiltInMiningProviderConfig } from "./config.js";
 import { MINING_WORKER_API_VERSION, MINING_WORKER_HEARTBEAT_STALE_MS, } from "./constants.js";
+import { estimateBuiltInModelDailyCost, getBuiltInProviderModelCatalog, getRecommendedBuiltInProviderModel, MINING_MODEL_DAILY_COST_ESTIMATE_ASSUMPTION, resolveBuiltInProviderSelection, } from "./provider-model.js";
+const KEEP_CURRENT_MODEL_SELECTION = "__keep_current__";
 function createMiningEvent(kind, message, options = {}) {
     return {
         schemaVersion: 1,
@@ -23,8 +26,14 @@ function buildProviderInspection(options) {
             provider: null,
             status: "error",
             message: options.error,
+            modelId: null,
+            effectiveModel: null,
             modelOverride: null,
+            modelSelectionSource: null,
+            usingDefaultModel: null,
             extraPromptConfigured: false,
+            estimatedDailyCostUsd: null,
+            estimatedDailyCostDisplay: null,
         };
     }
     if (options.config === null) {
@@ -33,19 +42,50 @@ function buildProviderInspection(options) {
             provider: null,
             status: "missing",
             message: "Built-in mining provider is not configured yet.",
+            modelId: null,
+            effectiveModel: null,
             modelOverride: null,
+            modelSelectionSource: null,
+            usingDefaultModel: null,
             extraPromptConfigured: false,
+            estimatedDailyCostUsd: null,
+            estimatedDailyCostDisplay: null,
         };
     }
+    const selection = resolveBuiltInProviderSelection(options.config);
+    const estimate = options.eligibleRootCount === null
+        ? null
+        : estimateBuiltInModelDailyCost(options.config.provider, selection.modelId, options.eligibleRootCount);
     return {
         configured: true,
         provider: options.config.provider,
         status: "ready",
         message: null,
+        modelId: selection.modelId,
+        effectiveModel: selection.effectiveModel,
         modelOverride: options.config.modelOverride,
+        modelSelectionSource: selection.modelSelectionSource,
+        usingDefaultModel: selection.usingDefaultModel,
         extraPromptConfigured: options.config.extraPrompt !== null && options.config.extraPrompt.length > 0,
+        estimatedDailyCostUsd: estimate?.estimatedDailyCostUsd ?? null,
+        estimatedDailyCostDisplay: estimate?.estimatedDailyCostDisplay ?? null,
     };
 }
+function countEligibleAnchoredRoots(localState) {
+    const state = localState.state;
+    if (state === null || state === undefined) {
+        return null;
+    }
+    let count = 0;
+    for (const domain of state.domains) {
+        if (isRootDomainName(domain.name)
+            && domain.canonicalChainStatus === "anchored"
+            && domain.currentOwnerScriptPubKeyHex === state.funding.scriptPubKeyHex) {
+            count += 1;
+        }
+    }
+    return count;
+}
 async function isProcessAlive(pid) {
     if (pid === null) {
         return false;
@@ -61,10 +101,13 @@ async function isProcessAlive(pid) {
         return true;
     }
 }
-function mapProviderState(provider, localState) {
+function mapProviderState(provider, localState, existingRuntime) {
     const miningState = localState.state?.miningState === undefined
         ? null
         : normalizeMiningStateRecord(localState.state.miningState);
+    if (existingRuntime?.currentPhase === "waiting-provider" && existingRuntime.providerState !== null) {
+        return existingRuntime.providerState;
+    }
     if (miningState?.state === "paused" && miningState.pauseReason?.includes("rate-limit")) {
         return "rate-limited";
     }
@@ -167,7 +210,7 @@ async function buildMiningRuntimeSnapshot(options) {
         localState: options.localState,
         nowUnixMs: options.nowUnixMs,
     });
-    const providerState = mapProviderState(options.provider, options.localState);
+    const providerState = mapProviderState(options.provider, options.localState, options.existingRuntime);
     const indexerDaemonState = mapIndexerDaemonState(options.indexer);
     const corePublishState = mapCorePublishState(options.nodeHealth, options.nodeStatus);
     const existing = options.existingRuntime;
@@ -289,7 +332,10 @@ export async function inspectMiningControlPlane(options) {
         paths,
         provider,
     });
-    const providerInspection = buildProviderInspection(providerConfig);
+    const providerInspection = buildProviderInspection({
+        ...providerConfig,
+        eligibleRootCount: countEligibleAnchoredRoots(options.localState),
+    });
     const existingRuntime = await loadMiningRuntimeStatus(paths.miningStatusPath).catch(() => null);
     const lastEventAtUnixMs = await getLastMiningEventTimestamp(paths.miningEventsPath).catch(() => null);
     const nodeBestHeight = options.nodeStatus?.nodeBestHeight ?? null;
@@ -323,6 +369,20 @@ function normalizeProviderChoice(raw) {
     const value = raw.trim().toLowerCase();
     return value === "openai" || value === "anthropic" ? value : null;
 }
+function describeModelSelectionSource(source) {
+    switch (source) {
+        case "catalog":
+            return "catalog";
+        case "custom":
+            return "custom";
+        case "legacy-default":
+            return "legacy-default";
+        case "legacy-custom":
+            return "legacy-custom";
+        default:
+            throw new Error(`unsupported_model_selection_source:${String(source)}`);
+    }
+}
 function writeBuiltInMiningProviderDisclosure(prompter) {
     prompter.writeLine("Built-in mining provider disclosure:");
     prompter.writeLine("The built-in mining provider will send the following to the selected provider:");
@@ -332,27 +392,194 @@ function writeBuiltInMiningProviderDisclosure(prompter) {
     prompter.writeLine("- referenced previous-block hash");
     prompter.writeLine("- optional extra prompt when configured");
 }
-async function promptForMiningProviderConfig(prompter) {
+async function promptForMiningProviderModelSelectionFallback(prompter, options) {
+    prompter.writeLine(options.message);
+    for (const [index, option] of options.options.entries()) {
+        const description = option.description == null || option.description.length === 0
+            ? ""
+            : ` - ${option.description}`;
+        prompter.writeLine(`${index + 1}. ${option.label}${description}`);
+    }
+    if (options.footer != null && options.footer.length > 0) {
+        prompter.writeLine(options.footer);
+    }
+    while (true) {
+        const answer = (await prompter.prompt(`Choice [1-${options.options.length}]: `)).trim();
+        if (/^(q|quit|esc|escape)$/i.test(answer)) {
+            throw new Error("mining_setup_canceled");
+        }
+        const choice = Number.parseInt(answer, 10);
+        if (Number.isInteger(choice) && choice >= 1 && choice <= options.options.length) {
+            return options.options[choice - 1].value;
+        }
+        prompter.writeLine(`Enter a number from 1 to ${options.options.length}, or q to cancel.`);
+    }
+}
+function formatMiningProviderDisplayName(provider) {
+    return provider === "openai" ? "OpenAI" : "Anthropic";
+}
+async function promptMiningSetupYesNo(prompter, message, defaultAnswer) {
+    const prompt = `${message}${defaultAnswer ? " [Y/n]: " : " [y/N]: "}`;
+    while (true) {
+        const answer = (await prompter.prompt(prompt)).trim().toLowerCase();
+        if (answer.length === 0) {
+            return defaultAnswer;
+        }
+        if (answer === "y" || answer === "yes") {
+            return true;
+        }
+        if (answer === "n" || answer === "no") {
+            return false;
+        }
+        if (answer === "q" || answer === "quit" || answer === "esc" || answer === "escape") {
+            throw new Error("mining_setup_canceled");
+        }
+        prompter.writeLine("Enter y or n, or q to cancel.");
+    }
+}
+function buildMiningProviderModelSelectorOptions(provider, eligibleRootCount, currentConfig) {
+    const catalogOptions = getBuiltInProviderModelCatalog(provider).map((entry) => {
+        const estimate = estimateBuiltInModelDailyCost(provider, entry.modelId, eligibleRootCount);
+        return {
+            label: entry.label,
+            description: `${entry.modelId} - ${estimate?.estimatedDailyCostDisplay ?? "n/a"}`,
+            value: entry.modelId,
+        };
+    });
+    const selection = currentConfig === null ? null : resolveBuiltInProviderSelection(currentConfig);
+    const options = [...catalogOptions];
+    let initialValue = getRecommendedBuiltInProviderModel(provider);
+    if (selection !== null) {
+        if (selection.modelSelectionSource === "custom" || selection.modelSelectionSource === "legacy-custom") {
+            initialValue = "custom";
+        }
+        else if (catalogOptions.some((entry) => entry.value === selection.modelId)) {
+            initialValue = selection.modelId;
+        }
+        else {
+            options.push({
+                label: "Current configured model",
+                description: `${selection.modelId} - current saved setting`,
+                value: KEEP_CURRENT_MODEL_SELECTION,
+            });
+            initialValue = KEEP_CURRENT_MODEL_SELECTION;
+        }
+    }
+    options.push({
+        label: "Custom model ID...",
+        description: "",
+        value: "custom",
+    });
+    return {
+        initialValue,
+        options,
+    };
+}
+async function promptForMiningProviderConfig(prompter, eligibleRootCount, options = {}) {
     writeBuiltInMiningProviderDisclosure(prompter);
-    const providerInput = await prompter.prompt("Provider (openai/anthropic): ");
-    const provider = normalizeProviderChoice(providerInput);
-    if (provider === null) {
-        throw new Error("mining_setup_invalid_provider");
+    const currentConfig = options.currentConfig ?? null;
+    const rememberedConfigs = options.rememberedConfigs ?? {};
+    let provider;
+    let rememberedConfig = currentConfig;
+    let reuseSavedApiKey = false;
+    if (currentConfig !== null) {
+        const useDifferentProviderOrApiKey = await promptMiningSetupYesNo(prompter, "Use a different provider or API key?", false);
+        if (!useDifferentProviderOrApiKey) {
+            provider = currentConfig.provider;
+            reuseSavedApiKey = true;
+        }
+        else {
+            const providerInput = await prompter.prompt("Provider (openai/anthropic): ");
+            const selectedProvider = normalizeProviderChoice(providerInput);
+            if (selectedProvider === null) {
+                throw new Error("mining_setup_invalid_provider");
+            }
+            provider = selectedProvider;
+            rememberedConfig = rememberedConfigs[provider] ?? null;
+            if (rememberedConfig !== null) {
+                reuseSavedApiKey = await promptMiningSetupYesNo(prompter, `Use saved ${formatMiningProviderDisplayName(provider)} API key?`, true);
+            }
+        }
+    }
+    else {
+        const providerInput = await prompter.prompt("Provider (openai/anthropic): ");
+        const selectedProvider = normalizeProviderChoice(providerInput);
+        if (selectedProvider === null) {
+            throw new Error("mining_setup_invalid_provider");
+        }
+        provider = selectedProvider;
+        rememberedConfig = rememberedConfigs[provider] ?? null;
+        if (rememberedConfig !== null) {
+            reuseSavedApiKey = await promptMiningSetupYesNo(prompter, `Use saved ${formatMiningProviderDisplayName(provider)} API key?`, true);
+        }
+    }
+    const selectorModelOptions = buildMiningProviderModelSelectorOptions(provider, eligibleRootCount, rememberedConfig);
+    const selectorOptions = {
+        message: "Choose the mining model:",
+        options: selectorModelOptions.options,
+        initialValue: selectorModelOptions.initialValue,
+        footer: MINING_MODEL_DAILY_COST_ESTIMATE_ASSUMPTION,
+    };
+    const selectedModelId = prompter.selectOption == null
+        ? await promptForMiningProviderModelSelectionFallback(prompter, selectorOptions)
+        : await prompter.selectOption(selectorOptions);
+    let modelSelectionSource;
+    let modelOverride;
+    if (selectedModelId === KEEP_CURRENT_MODEL_SELECTION) {
+        if (rememberedConfig === null) {
+            throw new Error("mining_setup_missing_model_id");
+        }
+        modelSelectionSource = rememberedConfig.modelSelectionSource;
+        modelOverride = rememberedConfig.modelOverride;
+    }
+    else if (selectedModelId === "custom") {
+        const currentCustomModel = rememberedConfig !== null
+            && (rememberedConfig.modelSelectionSource === "custom" || rememberedConfig.modelSelectionSource === "legacy-custom")
+            ? rememberedConfig.modelOverride
+            : null;
+        const customModelId = (await prompter.prompt(currentCustomModel === null
+            ? "Custom model ID: "
+            : `Custom model ID (blank to keep current: ${currentCustomModel}): `)).trim();
+        if (customModelId.length === 0) {
+            if (currentCustomModel === null) {
+                throw new Error("mining_setup_missing_model_id");
+            }
+            modelSelectionSource = rememberedConfig?.modelSelectionSource ?? "custom";
+            modelOverride = currentCustomModel;
+        }
+        else {
+            modelSelectionSource = "custom";
+            modelOverride = customModelId;
+        }
     }
-    const apiKey = (await prompter.prompt("API key: ")).trim();
+    else {
+        modelSelectionSource = "catalog";
+        modelOverride = selectedModelId;
+    }
+    const apiKey = reuseSavedApiKey && rememberedConfig !== null
+        ? rememberedConfig.apiKey
+        : (await prompter.prompt("API key: ")).trim();
     if (apiKey.length === 0) {
         throw new Error("mining_setup_missing_api_key");
     }
-    const extraPrompt = (await prompter.prompt("Extra prompt (optional, blank for none): ")).trim();
-    const modelOverride = (await prompter.prompt("Model override (optional, blank for default): ")).trim();
+    const extraPromptInput = (await prompter.prompt(rememberedConfig === null
+        ? "Extra prompt (optional, blank for none): "
+        : `Extra prompt (optional, blank to keep current: ${rememberedConfig.extraPrompt ?? "none"}): `)).trim();
+    const extraPrompt = extraPromptInput.length === 0
+        ? rememberedConfig?.extraPrompt ?? null
+        : extraPromptInput;
     return {
         provider,
         apiKey,
-        extraPrompt: extraPrompt.length === 0 ? null : extraPrompt,
-        modelOverride: modelOverride.length === 0 ? null : modelOverride,
+        extraPrompt: extraPrompt === null || extraPrompt.length === 0 ? null : extraPrompt,
+        modelOverride,
+        modelSelectionSource,
         updatedAtUnixMs: Date.now(),
     };
 }
+export async function promptForMiningProviderConfigForTesting(prompter, eligibleRootCount, options = {}) {
+    return await promptForMiningProviderConfig(prompter, eligibleRootCount, options);
+}
 export async function setupBuiltInMining(options) {
     if (!options.prompter.isInteractive) {
         throw new Error("mine_setup_requires_tty");
@@ -375,9 +602,28 @@ export async function setupBuiltInMining(options) {
             }, {
                 provider,
             });
+            const localState = {
+                availability: "ready",
+                clientPasswordReadiness: "ready",
+                unlockRequired: false,
+                walletRootId: loaded.state.walletRootId,
+                state: loaded.state,
+                source: loaded.source,
+                hasPrimaryStateFile: true,
+                hasBackupStateFile: true,
+                message: null,
+            };
+            const eligibleRootCount = countEligibleAnchoredRoots(localState) ?? 0;
+            const clientConfig = await loadClientConfig({
+                path: paths.clientConfigPath,
+                provider,
+            }).catch(() => null);
             await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-started", "Started built-in mining provider setup.", { timestampUnixMs: nowUnixMs }));
             try {
-                const config = await promptForMiningProviderConfig(options.prompter);
+                const config = await promptForMiningProviderConfig(options.prompter, eligibleRootCount, {
+                    currentConfig: clientConfig?.mining.builtIn ?? null,
+                    rememberedConfigs: clientConfig?.mining.builtInByProvider ?? {},
+                });
                 config.updatedAtUnixMs = nowUnixMs;
                 await saveBuiltInMiningProviderConfig({
                     path: paths.clientConfigPath,
@@ -385,20 +631,10 @@ export async function setupBuiltInMining(options) {
                     secretReference: createWalletSecretReference(loaded.state.walletRootId),
                     config,
                 });
-                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-completed", `Configured the built-in ${config.provider} mining provider.`, { timestampUnixMs: nowUnixMs }));
+                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-completed", `Configured the built-in ${config.provider} mining provider with model ${config.modelOverride} (${describeModelSelectionSource(config.modelSelectionSource)}).`, { timestampUnixMs: nowUnixMs }));
                 return refreshMiningRuntimeStatus({
                     provider,
-                    localState: {
-                        availability: "ready",
-                        clientPasswordReadiness: "ready",
-                        unlockRequired: false,
-                        walletRootId: loaded.state.walletRootId,
-                        state: loaded.state,
-                        source: loaded.source,
-                        hasPrimaryStateFile: true,
-                        hasBackupStateFile: true,
-                        message: null,
-                    },
+                    localState,
                     bitcoind: {
                         health: "unavailable",
                         status: null,
@@ -421,6 +657,13 @@ export async function setupBuiltInMining(options) {
                 });
             }
             catch (error) {
+                if (error instanceof Error && error.message === "mining_setup_canceled") {
+                    await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-canceled", "Canceled built-in mining provider setup.", {
+                        level: "warn",
+                        timestampUnixMs: nowUnixMs,
+                    }));
+                    throw error;
+                }
                 await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-failed", error instanceof Error ? error.message : String(error), {
                     level: "error",
                     timestampUnixMs: nowUnixMs,

package/dist/wallet/mining/domain-prompts.d.ts

@@ -0,0 +1,17 @@
+import type { WalletReadContext } from "../read/index.js";
+import { type WalletSecretProvider } from "../state/provider.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { MiningDomainPromptListResult, MiningDomainPromptMutationResult } from "./types.js";
+export declare function canonicalizeMiningDomainPromptName(domainName: string): string;
+export declare function inspectMiningDomainPromptState(options: {
+    paths: WalletRuntimePaths;
+    provider: WalletSecretProvider;
+    readContext: WalletReadContext;
+}): Promise<MiningDomainPromptListResult>;
+export declare function updateMiningDomainPrompt(options: {
+    paths: WalletRuntimePaths;
+    provider: WalletSecretProvider;
+    readContext: WalletReadContext;
+    domainName: string;
+    prompt: string | null;
+}): Promise<MiningDomainPromptMutationResult>;

package/dist/wallet/mining/domain-prompts.js

@@ -0,0 +1,130 @@
+import { findWalletDomain, isMineableWalletDomain } from "../read/index.js";
+import { createWalletSecretReference } from "../state/provider.js";
+import { loadClientConfig, saveClientConfig } from "./config.js";
+function createEmptyClientConfig() {
+    return {
+        schemaVersion: 1,
+        mining: {
+            builtIn: null,
+            domainExtraPrompts: {},
+        },
+    };
+}
+export function canonicalizeMiningDomainPromptName(domainName) {
+    return domainName.trim().toLowerCase();
+}
+function fallbackPromptConfigured(config) {
+    const extraPrompt = config?.mining.builtIn?.extraPrompt ?? null;
+    return extraPrompt !== null && extraPrompt.length > 0;
+}
+function listMineableDomains(readContext) {
+    const domains = new Map();
+    for (const domain of readContext.model?.domains ?? []) {
+        if (!isMineableWalletDomain(readContext, domain)) {
+            continue;
+        }
+        domains.set(canonicalizeMiningDomainPromptName(domain.name), {
+            name: domain.name,
+            domainId: domain.domainId,
+        });
+    }
+    return domains;
+}
+function buildPromptEntries(options) {
+    const entries = new Map();
+    const mineableDomains = listMineableDomains(options.readContext);
+    for (const domain of mineableDomains.values()) {
+        const canonicalDomainName = canonicalizeMiningDomainPromptName(domain.name);
+        const prompt = options.domainExtraPrompts[canonicalDomainName] ?? null;
+        entries.set(canonicalDomainName, {
+            domain,
+            mineable: true,
+            prompt,
+            effectivePromptSource: prompt !== null
+                ? "domain"
+                : options.fallbackPromptConfigured
+                    ? "global-fallback"
+                    : "none",
+        });
+    }
+    for (const [domainName, prompt] of Object.entries(options.domainExtraPrompts)) {
+        if (entries.has(domainName)) {
+            continue;
+        }
+        const found = findWalletDomain(options.readContext, domainName);
+        entries.set(domainName, {
+            domain: {
+                name: domainName,
+                domainId: found?.domain.domainId ?? null,
+            },
+            mineable: false,
+            prompt,
+            effectivePromptSource: "domain",
+        });
+    }
+    return [...entries.values()].sort((left, right) => left.domain.name.localeCompare(right.domain.name));
+}
+function isMineableTarget(readContext, domainName) {
+    const domain = readContext.model?.domains.find((entry) => canonicalizeMiningDomainPromptName(entry.name) === domainName);
+    return domain === undefined ? false : isMineableWalletDomain(readContext, domain);
+}
+export async function inspectMiningDomainPromptState(options) {
+    const config = await loadClientConfig({
+        path: options.paths.clientConfigPath,
+        provider: options.provider,
+    });
+    return {
+        fallbackPromptConfigured: fallbackPromptConfigured(config),
+        prompts: buildPromptEntries({
+            readContext: options.readContext,
+            domainExtraPrompts: config?.mining.domainExtraPrompts ?? {},
+            fallbackPromptConfigured: fallbackPromptConfigured(config),
+        }),
+    };
+}
+export async function updateMiningDomainPrompt(options) {
+    const canonicalDomainName = canonicalizeMiningDomainPromptName(options.domainName);
+    const config = await loadClientConfig({
+        path: options.paths.clientConfigPath,
+        provider: options.provider,
+    });
+    const currentPrompts = {
+        ...(config?.mining.domainExtraPrompts ?? {}),
+    };
+    const existingPrompt = currentPrompts[canonicalDomainName] ?? null;
+    const mineable = isMineableTarget(options.readContext, canonicalDomainName);
+    const found = findWalletDomain(options.readContext, canonicalDomainName);
+    const nextPrompt = options.prompt === null || options.prompt.trim().length === 0
+        ? null
+        : options.prompt.trim();
+    if (!mineable && existingPrompt === null) {
+        throw new Error("mine_prompt_domain_not_mineable");
+    }
+    if (options.readContext.localState.walletRootId === null) {
+        throw new Error("wallet_uninitialized");
+    }
+    if (nextPrompt === null) {
+        delete currentPrompts[canonicalDomainName];
+    }
+    else {
+        currentPrompts[canonicalDomainName] = nextPrompt;
+    }
+    const nextConfig = config ?? createEmptyClientConfig();
+    nextConfig.mining.domainExtraPrompts = currentPrompts;
+    await saveClientConfig({
+        path: options.paths.clientConfigPath,
+        provider: options.provider,
+        secretReference: createWalletSecretReference(options.readContext.localState.walletRootId),
+        config: nextConfig,
+    });
+    return {
+        domain: {
+            name: canonicalDomainName,
+            domainId: found?.domain.domainId ?? null,
+        },
+        previousPrompt: existingPrompt,
+        prompt: nextPrompt,
+        status: nextPrompt === null ? "cleared" : "updated",
+        fallbackPromptConfigured: fallbackPromptConfigured(config),
+    };
+}

package/dist/wallet/mining/index.d.ts

@@ -1,7 +1,8 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
+export { canonicalizeMiningDomainPromptName, inspectMiningDomainPromptState, updateMiningDomainPrompt, } from "./domain-prompts.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
 export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, type MiningStartResult, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 export type { MiningSentenceCandidateV1, MiningSentenceGenerationRequestV1, MiningSentenceGenerationResponseV1, } from "./sentence-protocol.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";
-export type { ClientConfigV1, MiningControlPlaneView, MiningEventRecord, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";
+export type { ClientConfigV1, MiningControlPlaneView, MiningDomainPromptEntry, MiningDomainPromptListResult, MiningDomainPromptMutationResult, MiningEventRecord, MiningModelSelectionSource, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";

package/dist/wallet/mining/index.js

@@ -1,4 +1,5 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
+export { canonicalizeMiningDomainPromptName, inspectMiningDomainPromptState, updateMiningDomainPrompt, } from "./domain-prompts.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
 export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";

package/dist/wallet/mining/provider-model.d.ts

@@ -0,0 +1,30 @@
+import type { MiningModelSelectionSource, MiningProviderConfigRecord, MiningProviderKind } from "./types.js";
+export interface BuiltInProviderModelCatalogEntry {
+    label: string;
+    modelId: string;
+    inputUsdPerMillionTokens: number;
+    outputUsdPerMillionTokens: number;
+}
+export interface BuiltInProviderSelection {
+    modelId: string;
+    effectiveModel: string;
+    modelSelectionSource: MiningModelSelectionSource;
+    usingDefaultModel: boolean;
+}
+export interface BuiltInModelDailyCostEstimate {
+    estimatedDailyCostUsd: number;
+    estimatedDailyCostDisplay: string;
+}
+export declare const MINING_MODEL_DAILY_COST_ESTIMATE_ASSUMPTION = "Approximate daily cost assumes 144 sentence-generation calls/day using your current anchored root count, standard token pricing, no caching, and no extra prompt.";
+export declare function getLegacyBuiltInProviderDefaultModel(provider: MiningProviderKind): string;
+export declare function getRecommendedBuiltInProviderModel(provider: MiningProviderKind): string;
+export declare function getBuiltInProviderModelCatalog(provider: MiningProviderKind): readonly BuiltInProviderModelCatalogEntry[];
+export declare function findBuiltInProviderModelCatalogEntry(provider: MiningProviderKind, modelId: string): BuiltInProviderModelCatalogEntry | null;
+export declare function normalizeMiningModelSelectionSource(raw: unknown, modelOverride: string | null): MiningModelSelectionSource;
+export declare function normalizeMiningProviderConfigRecord(config: MiningProviderConfigRecord): MiningProviderConfigRecord;
+export declare function resolveBuiltInProviderModel(provider: MiningProviderKind, modelOverride: string | null): {
+    effectiveModel: string;
+    usingDefaultModel: boolean;
+};
+export declare function resolveBuiltInProviderSelection(config: Pick<MiningProviderConfigRecord, "provider" | "modelOverride" | "modelSelectionSource">): BuiltInProviderSelection;
+export declare function estimateBuiltInModelDailyCost(provider: MiningProviderKind, modelId: string, eligibleRootCount: number): BuiltInModelDailyCostEstimate | null;