@deepthonk/mcp 0.1.0 → 0.1.2

package/dist/tools.js

@@ -1,9 +1,12 @@
-import { readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
+import { dirname, join } from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
-import { builtInProfiles, claimRunLock, ConfigError, DeepThonkError, getProfile, planBudget, detectResumeState, exportRun, isRunCancelRequested, mutateCandidate, rankCandidates, readRunStatus, requestRunCancel, runDeepThonk, TraceStore } from "@deepthonk/core";
-import { createDriver, defaultPricesForProviderConfig, resolveProviderConfig, resolveProviderModels } from "@deepthonk/providers";
+import { builtInProfiles, claimRunLock, ConfigError, DeepThonkError, getProfile, planBudget, detectResumeState, exportRun, isRunCancelRequested, mutateCandidate, rankCandidates, readRunStatus, requestRunCancel, resumeDeepThonk, runConfigSchema, runDeepThonk, TraceStore } from "@deepthonk/core";
+import { createDriver, defaultPricesForProviderConfig, listProfiles, loadDeepThonkEnv, loadNamedProfile, NAMED_PROFILE_NAME_RE, profilePath, profilesDir, rejectAllSecretShapedFields, rejectRawApiKeyFields, resolveProviderConfig, resolveProviderModels, SECRET_KEY_RE, validateNamedProfileBundle } from "@deepthonk/providers";
 import { recordRunResource } from "./resources.js";
 export const toolNames = [
     "deepthonk.plan",
@@ -15,9 +18,15 @@ export const toolNames = [
     "deepthonk.rank",
     "deepthonk.mutate",
     "deepthonk.resume",
-    "deepthonk.export"
+    "deepthonk.export",
+    "deepthonk.profile_list",
+    "deepthonk.profile_show",
+    "deepthonk.profile_save",
+    "deepthonk.profile_delete"
 ];
 export const planArgsSchema = z.object({
+    config_path: z.string().optional().describe("Optional DeepThonk YAML config path."),
+    profile_name: z.string().optional().describe("Saved profile bundle name; loads ~/.config/deepthonk/profiles/<name>.yaml. Mutually exclusive with config_path."),
     profile: z.enum(["quick", "balanced", "paper"]).default("quick"),
     n: z.number().int().min(2).optional(),
     k: z.number().int().min(1).optional(),
@@ -28,12 +37,12 @@ const providerNameSchema = z
     .string()
     .min(1)
     .describe("Provider label. Built-ins include fake, deepseek, openrouter, and openai-compatible; custom labels require base_url.")
-    .refine((provider) => provider !== "sampling", "MCP Sampling is deferred and is not a direct provider option.")
     .default("fake");
 export const runArgsSchema = z.object({
     task: z.string().min(1).describe("Task text to solve. MCP tools do not read task files."),
     rubric: z.string().optional().describe("Optional judging rubric text."),
     config_path: z.string().optional().describe("Optional DeepThonk YAML config path, such as ~/.config/deepthonk/config.yaml."),
+    profile_name: z.string().optional().describe("Saved profile bundle name; loads ~/.config/deepthonk/profiles/<name>.yaml. Mutually exclusive with config_path."),
     profile: z.enum(["quick", "balanced", "paper"]).default("quick").describe("Run profile. quick is safest for smoke tests; paper plans 285 calls."),
     prompt_style: z.enum(["general", "paper-programming"]).optional().describe("Prompt template style. Defaults to paper-programming for the paper profile, general otherwise."),
     provider: providerNameSchema,
@@ -43,6 +52,10 @@ export const runArgsSchema = z.object({
     mutator_model: z.string().optional().describe("Model used for critique-guided mutation."),
     judge_model: z.string().optional().describe("Model used for pairwise judging."),
     finalizer_model: z.string().optional().describe("Optional model used to polish the winning candidate."),
+    sampling_model_hints: z.array(z.string()).optional().describe("Optional MCP Sampling model hints. Hints guide host model choice but do not enforce it."),
+    sampling_cost_priority: z.number().min(0).max(1).optional().describe("MCP Sampling model preference for lower cost, from 0 to 1."),
+    sampling_speed_priority: z.number().min(0).max(1).optional().describe("MCP Sampling model preference for speed, from 0 to 1."),
+    sampling_intelligence_priority: z.number().min(0).max(1).optional().describe("MCP Sampling model preference for intelligence, from 0 to 1."),
     seed: z.number().int().default(1).describe("Deterministic seed for pair ordering and IDs."),
     run_dir: z.string().optional().describe("Directory for trace files."),
     max_calls: z.number().int().optional().describe("Maximum completed provider calls before the run stops at a phase boundary."),
@@ -58,16 +71,18 @@ export const runArgsSchema = z.object({
     sample_temperature: z.number().min(0).optional().describe("Temperature for initial candidate generation."),
     mutate_temperature: z.number().min(0).optional().describe("Temperature for critique-guided mutation."),
     judge_temperature: z.number().min(0).optional().describe("Temperature for pairwise judging."),
+    include_prompts: z.boolean().optional().describe("Store rendered prompts in candidate/comparison metadata."),
+    include_raw_model_outputs: z.boolean().optional().describe("Store raw provider responses in trace metadata."),
     concurrency: z.object({
         generate: z.number().int().min(1).optional(),
         judge: z.number().int().min(1).optional(),
         mutate: z.number().int().min(1).optional()
     }).optional().describe("Per-phase concurrency overrides."),
     prompts: z.object({
-        generate: z.object({ system: z.string().optional(), user: z.string().optional() }).optional(),
-        compare: z.object({ system: z.string().optional(), user: z.string().optional() }).optional(),
-        mutate: z.object({ system: z.string().optional(), user: z.string().optional() }).optional(),
-        finalize: z.object({ system: z.string().optional(), user: z.string().optional() }).optional()
+        generate: z.object({ system: z.string().optional(), user: z.string().optional() }).describe("Variables: {task}, {rubric}").optional(),
+        compare: z.object({ system: z.string().optional(), user: z.string().optional() }).describe("Variables: {task}, {rubric}, {candidateA}, {candidateB}. Output must be strict JSON: {feedback_a, feedback_b, winner: A|B|tie}.").optional(),
+        mutate: z.object({ system: z.string().optional(), user: z.string().optional() }).describe("Variables: {task}, {rubric}, {candidate}, {critique}").optional(),
+        finalize: z.object({ system: z.string().optional(), user: z.string().optional() }).describe("Variables: {task}, {rubric}, {candidate}").optional()
     }).optional().describe("Optional per-phase prompt template overrides. Templates use {task}, {rubric}, {candidate}, {candidateA}, {candidateB}, {critique} placeholders. Use {{ and }} to escape literal braces. See docs/customization.md for the variable contract per phase.")
 });
 export const jobArgsSchema = z.object({
@@ -76,6 +91,7 @@ export const jobArgsSchema = z.object({
 });
 const providerArgsSchema = z.object({
     config_path: z.string().optional().describe("Optional DeepThonk YAML config path."),
+    profile_name: z.string().optional().describe("Saved profile bundle name; loads ~/.config/deepthonk/profiles/<name>.yaml. Mutually exclusive with config_path."),
     provider: providerNameSchema,
     base_url: z.string().optional().describe("OpenAI-compatible base URL, ending at /v1."),
     api_key_env: z.string().optional().describe("Environment variable that contains the API key."),
@@ -87,16 +103,29 @@ const providerArgsSchema = z.object({
 export const rankArgsSchema = providerArgsSchema.extend({
     task: z.string().min(1).describe("Task text the candidates answer."),
     rubric: z.string().optional().describe("Optional judging rubric text."),
-    candidates: z.array(z.union([z.string(), z.object({ id: z.string().optional(), content: z.string() })])).min(2).describe("Candidate texts or {id, content} objects.")
+    candidates: z.array(z.union([z.string(), z.object({ id: z.string().optional(), content: z.string() })])).min(2).describe("Candidate texts or {id, content} objects."),
+    judge_temperature: z.number().min(0).optional().describe("Temperature for pairwise judging."),
+    lambda: z.number().min(0).optional().describe("Bradley-Terry L2 regularization."),
+    concurrency: z.number().int().min(1).optional().describe("Maximum concurrent pairwise comparisons."),
+    prompt_style: z.enum(["general", "paper-programming"]).optional(),
+    prompts: z.object({
+        compare: z.object({ system: z.string().optional(), user: z.string().optional() }).describe("Variables: {task}, {rubric}, {candidateA}, {candidateB}. Output must be strict JSON: {feedback_a, feedback_b, winner: A|B|tie}.").optional()
+    }).optional()
 });
 export const mutateArgsSchema = providerArgsSchema.extend({
     task: z.string().min(1).describe("Task text the candidate answers."),
     rubric: z.string().optional().describe("Optional rubric text."),
     candidate: z.string().describe("Candidate text to mutate."),
-    critique: z.string().default("").describe("Critique or guidance for mutation.")
+    critique: z.string().default("").describe("Critique or guidance for mutation."),
+    mutate_temperature: z.number().min(0).optional().describe("Temperature for mutation."),
+    prompt_style: z.enum(["general", "paper-programming"]).optional(),
+    prompts: z.object({
+        mutate: z.object({ system: z.string().optional(), user: z.string().optional() }).describe("Variables: {task}, {rubric}, {candidate}, {critique}").optional()
+    }).optional()
 });
 export const resumeArgsSchema = z.object({
-    run_dir: z.string()
+    run_dir: z.string(),
+    continue: z.boolean().optional()
 });
 export const exportArgsSchema = z.object({
     run_dir: z.string(),
@@ -151,9 +180,15 @@ export const mutateOutputSchema = z.object({
 });
 export function deepthonkPlan(argsInput) {
     const args = planArgsSchema.parse(argsInput);
-    if (args.n === undefined && args.k === undefined && args.t === undefined && args.m === undefined) {
+    if (args.config_path === undefined && args.profile_name === undefined && args.n === undefined && args.k === undefined && args.t === undefined && args.m === undefined) {
         return planBudget(args.profile);
     }
+    if (args.config_path !== undefined || args.profile_name !== undefined) {
+        throw new ConfigError("deepthonk.plan with config_path or profile_name is async; use deepthonkPlanAsync.", {
+            code: "mcp.plan_async_required",
+            retryable: false
+        });
+    }
     const base = builtInProfiles[args.profile];
     return planBudget({
         ...base,
@@ -163,8 +198,25 @@ export function deepthonkPlan(argsInput) {
         m: args.m ?? base.m
     });
 }
-export async function deepthonkStart(argsInput) {
-    const { runConfig, providerConfig } = await resolveMcpRun(argsInput);
+export async function deepthonkPlanAsync(argsInput) {
+    const args = planArgsSchema.parse(argsInput);
+    const config = await readMcpConfig(args.config_path, args.profile_name);
+    const profileName = config.profile ?? args.profile;
+    const base = builtInProfiles[profileName];
+    return planBudget({
+        ...base,
+        n: args.n ?? config.algorithm?.n ?? base.n,
+        k: args.k ?? config.algorithm?.k ?? base.k,
+        t: args.t ?? config.algorithm?.t ?? base.t,
+        m: args.m ?? config.algorithm?.m ?? base.m,
+        lambda: config.algorithm?.lambda ?? base.lambda,
+        sampleTemperature: config.algorithm?.sample_temperature ?? base.sampleTemperature,
+        mutateTemperature: config.algorithm?.mutate_temperature ?? base.mutateTemperature,
+        judgeTemperature: config.algorithm?.judge_temperature ?? base.judgeTemperature
+    });
+}
+export async function deepthonkStart(argsInput, context) {
+    const { runConfig, providerConfig } = await resolveMcpRun(argsInput, context);
     const jobId = `job_${new Date().toISOString().replace(/[:.]/g, "-")}_${Math.random().toString(16).slice(2, 8)}`;
     const now = new Date().toISOString();
     const claimed = await claimRunLock(runConfig.runDir, jobId);
@@ -209,7 +261,7 @@ export async function deepthonkStart(argsInput) {
         .catch(async (error) => {
         try {
             const existing = await readRunStatus(runConfig.runDir);
-            if (existing && existing.state !== "pending")
+            if (existing && ["completed", "failed", "cancelled", "budget_exceeded"].includes(existing.state))
                 return;
             const serialized = serializeToolError(error, runConfig.runDir);
             await new TraceStore(runConfig.runDir).writeStatus({
@@ -290,8 +342,8 @@ export async function deepthonkCancel(argsInput) {
         status: (await readRunStatus(runDir)) ?? { state: "cancel_requested", phase: "cancel_requested" }
     };
 }
-export async function deepthonkRun(argsInput) {
-    const { runConfig, providerConfig } = await resolveMcpRun(argsInput);
+export async function deepthonkRun(argsInput, context) {
+    const { runConfig, providerConfig } = await resolveMcpRun(argsInput, context);
     const result = await runDeepThonk(runConfig, createDriver(providerConfig), {
         shouldCancel: () => isRunCancelRequested(runConfig.runDir)
     });
@@ -305,17 +357,23 @@ export async function deepthonkRun(argsInput) {
         run_dir: result.runDir
     };
 }
-async function resolveMcpRun(argsInput) {
+async function resolveMcpRun(argsInput, context) {
     const raw = objectInput(argsInput);
     const args = runArgsSchema.parse(argsInput);
-    const config = await readMcpConfig(args.config_path);
+    const config = await readMcpConfig(args.config_path, args.profile_name);
     const profileName = (raw.profile ?? config.profile ?? args.profile);
     const baseProfile = getProfile(profileName);
     const profile = mergeProfileOverrides(baseProfile, config.algorithm, args);
-    const providerConfig = resolveMcpProviderConfig(args, raw, config);
+    const providerConfig = resolveMcpProviderConfig(args, raw, config, context?.createMessage);
+    assertSamplingCapability(providerConfig, context);
     const models = providerConfig.models;
     const runDir = args.run_dir ?? `runs/mcp-${new Date().toISOString().replace(/[:.]/g, "-")}`;
     const promptOverrides = mergePromptOverrides(config.prompts, args.prompts);
+    const concurrency = capSamplingConcurrency(providerConfig.provider, profile, {
+        generate: args.concurrency?.generate ?? config.concurrency?.generate ?? profile.n,
+        judge: args.concurrency?.judge ?? config.concurrency?.judge ?? Math.max(1, (profile.n * Math.max(profile.k, profile.m)) / 2),
+        mutate: args.concurrency?.mutate ?? config.concurrency?.mutate ?? profile.n - Math.floor(profile.n / 4)
+    });
     return {
         runConfig: {
             task: args.task,
@@ -330,11 +388,7 @@ async function resolveMcpRun(argsInput) {
             mutatorModel: models.mutator,
             judgeModel: models.judge,
             finalizerModel: models.finalizer,
-            concurrency: {
-                generate: args.concurrency?.generate ?? config.concurrency?.generate ?? profile.n,
-                judge: args.concurrency?.judge ?? config.concurrency?.judge ?? Math.max(1, (profile.n * Math.max(profile.k, profile.m)) / 2),
-                mutate: args.concurrency?.mutate ?? config.concurrency?.mutate ?? profile.n - Math.floor(profile.n / 4)
-            },
+            concurrency,
             retry: {
                 httpRetries: config.retry?.httpRetries ?? 2,
                 invalidJsonRetries: config.retry?.invalidJsonRetries ?? 1,
@@ -347,8 +401,8 @@ async function resolveMcpRun(argsInput) {
                 maxUsd: args.max_usd
             }, defaultPricesForProviderConfig(providerConfig)),
             output: {
-                includeRawModelOutputs: config.output?.includeRawModelOutputs ?? false,
-                includePrompts: config.output?.includePrompts ?? false
+                includeRawModelOutputs: args.include_raw_model_outputs ?? config.output?.includeRawModelOutputs ?? false,
+                includePrompts: args.include_prompts ?? config.output?.includePrompts ?? false
             }
         },
         providerConfig
@@ -360,7 +414,19 @@ export async function deepthonkRank(argsInput) {
     const models = providerConfig.models;
     const driver = createDriver(providerConfig);
     const candidates = args.candidates;
-    const result = await rankCandidates({ task: args.task, rubric: args.rubric, candidates, driver, judgeModel: models.judge, runId: "mcp-rank" });
+    const result = await rankCandidates({
+        task: args.task,
+        rubric: args.rubric,
+        candidates,
+        driver,
+        judgeModel: models.judge,
+        runId: "mcp-rank",
+        temperature: args.judge_temperature,
+        lambda: args.lambda,
+        concurrency: args.concurrency,
+        promptStyle: args.prompt_style,
+        promptOverrides: args.prompts
+    });
     return { scores: result.scores, comparisons: result.comparisons };
 }
 export async function deepthonkMutate(argsInput) {
@@ -374,13 +440,44 @@ export async function deepthonkMutate(argsInput) {
             candidate: { id: "mcp-candidate", content: args.candidate },
             driver: createDriver(providerConfig),
             mutatorModel: models.mutator,
-            temperature: 0.6,
-            critique: args.critique
+            temperature: args.mutate_temperature,
+            critique: args.critique,
+            promptStyle: args.prompt_style,
+            promptOverrides: args.prompts
         }))
     };
 }
-export async function deepthonkResume(argsInput) {
+export async function deepthonkResume(argsInput, context) {
     const args = resumeArgsSchema.parse(argsInput);
+    if (args.continue === true) {
+        const raw = JSON.parse(await readFile(join(args.run_dir, "config.json"), "utf8"));
+        const config = runConfigSchema.parse(raw);
+        const providerConfig = resolveProviderConfig({
+            provider: config.provider,
+            models: {
+                generator: config.generatorModel,
+                mutator: config.mutatorModel,
+                judge: config.judgeModel,
+                finalizer: config.finalizerModel
+            },
+            samplingTransport: config.provider === "sampling" ? context?.createMessage : undefined
+        });
+        assertSamplingCapability(providerConfig, context);
+        const result = await resumeDeepThonk(args.run_dir, createDriver(providerConfig), { provider: config.provider });
+        if ("winner" in result) {
+            return {
+                status: "completed",
+                message: "Run resumed and completed.",
+                run_id: result.runId,
+                run_dir: result.runDir,
+                winner_id: result.winner.id,
+                final_answer: result.finalAnswer,
+                calls: result.calls,
+                safe_to_continue: false
+            };
+        }
+        return { ...result };
+    }
     return { ...(await detectResumeState(args.run_dir)) };
 }
 export async function deepthonkExport(argsInput) {
@@ -388,12 +485,12 @@ export async function deepthonkExport(argsInput) {
     return exportRun(args.run_dir, args.format);
 }
 async function providerConfigFromArgs(args) {
-    const config = await readMcpConfig(args.config_path);
+    const config = await readMcpConfig(args.config_path, args.profile_name);
     return resolveMcpProviderConfig(args, objectInput(args), config);
 }
-function resolveMcpProviderConfig(args, raw, config) {
+function resolveMcpProviderConfig(args, raw, config, samplingTransport) {
     const provider = String(raw.provider ?? config.provider ?? args.provider);
-    return resolveProviderConfig({
+    const resolved = resolveProviderConfig({
         provider,
         baseUrl: args.base_url ?? config.base_url,
         apiKeyEnv: args.api_key_env ?? config.api_key_env,
@@ -411,6 +508,39 @@ function resolveMcpProviderConfig(args, raw, config) {
         })),
         retry: { httpRetries: 2, requestTimeoutMs: config.retry?.requestTimeoutMs }
     });
+    if (provider !== "sampling")
+        return resolved;
+    return {
+        ...resolved,
+        samplingTransport,
+        modelHints: args.sampling_model_hints,
+        costPriority: args.sampling_cost_priority,
+        speedPriority: args.sampling_speed_priority,
+        intelligencePriority: args.sampling_intelligence_priority,
+        includeRawOutputs: args.include_raw_model_outputs ?? config.output?.includeRawModelOutputs ?? false
+    };
+}
+function assertSamplingCapability(providerConfig, context) {
+    if (providerConfig.provider !== "sampling")
+        return;
+    const capabilities = context?.getClientCapabilities();
+    if (!capabilities?.sampling) {
+        throw new ConfigError("Connected MCP client does not advertise sampling capability. This client cannot serve as a sampling provider.", {
+            code: "provider.sampling_capability_missing",
+            retryable: false,
+            fix: "Use an MCP client that supports sampling, or choose a direct provider such as deepseek, openrouter, or openai-compatible."
+        });
+    }
+}
+function capSamplingConcurrency(provider, profile, concurrency) {
+    if (provider !== "sampling")
+        return concurrency;
+    const cap = Math.min(profile.n, 4);
+    return {
+        generate: Math.min(concurrency.generate, cap),
+        judge: Math.min(concurrency.judge, cap),
+        mutate: Math.min(concurrency.mutate, cap)
+    };
 }
 export function toolResult(value) {
     const structuredContent = typeof value === "object" && value !== null && !Array.isArray(value) ? value : { value };
@@ -444,7 +574,18 @@ function mergeProfileOverrides(base, fileOverrides, args) {
         judgeTemperature: args.judge_temperature ?? fileOverrides?.judge_temperature ?? base.judgeTemperature
     };
 }
-async function readMcpConfig(path) {
+async function readMcpConfig(path, profileName) {
+    await loadDeepThonkEnv();
+    if (profileName) {
+        if (path) {
+            throw new ConfigError("profile_name and config_path cannot be used together. A named profile replaces the config file.", {
+                code: "config.profile_and_config_conflict",
+                retryable: false,
+                fix: "Choose one: profile_name to load a saved bundle, or config_path to point at a config YAML."
+            });
+        }
+        return (await loadNamedProfile(profileName));
+    }
     if (!path)
         return {};
     return YAML.parse(await readFile(resolveMcpPath(path), "utf8"));
@@ -552,4 +693,159 @@ function serializeToolError(error, runDir) {
         run_dir: runDir
     };
 }
+export const profileListArgsSchema = z.object({});
+export const profileNameArgsSchema = z.object({
+    name: z.string().min(1)
+});
+export const profileSaveArgsSchema = z.object({
+    name: z.string().min(1),
+    force: z.boolean().optional(),
+    profile: z.enum(["quick", "balanced", "paper"]).optional(),
+    prompt_style: z.enum(["general", "paper-programming"]).optional(),
+    provider: z.string().min(1).optional(),
+    base_url: z.string().optional(),
+    api_key_env: z.string().optional(),
+    models: z.object({
+        generator: z.string().optional(),
+        mutator: z.string().optional(),
+        judge: z.string().optional(),
+        finalizer: z.string().optional()
+    }).optional(),
+    providers: z.record(z.unknown()).optional(),
+    algorithm: z.record(z.unknown()).optional(),
+    prompts: z.record(z.object({ system: z.string().optional(), user: z.string().optional() })).optional(),
+    budget: z.unknown().optional(),
+    concurrency: z.unknown().optional(),
+    retry: z.unknown().optional(),
+    output: z.unknown().optional()
+}).strict();
+export const profileListOutputSchema = z.object({
+    profiles: z.array(z.string())
+});
+export const profileShowOutputSchema = z.object({
+    profile: z.object({}).passthrough()
+});
+export const profileSaveOutputSchema = z.object({
+    path: z.string()
+});
+export const profileDeleteOutputSchema = z.object({
+    deleted: z.string()
+});
+export async function deepthonkProfileList(_argsInput) {
+    profileListArgsSchema.parse(_argsInput ?? {});
+    return { profiles: await listProfiles() };
+}
+export async function deepthonkProfileShow(argsInput) {
+    const args = profileNameArgsSchema.parse(argsInput);
+    return { profile: redactedProfile(await loadNamedProfile(args.name)) };
+}
+export async function deepthonkProfileSave(argsInput) {
+    rejectRawApiKeyFields(argsInput, "profile_save");
+    rejectAllSecretShapedFields(argsInput, "profile_save");
+    const args = parseProfileSaveArgs(argsInput);
+    const { name, force, ...profile } = args;
+    const path = await saveMcpProfileBundle(name, stripUndefined(profile), Boolean(force));
+    return { path };
+}
+export async function deepthonkProfileDelete(argsInput) {
+    const args = profileNameArgsSchema.parse(argsInput);
+    await loadNamedProfile(args.name);
+    const path = profilePath(args.name);
+    await unlink(path);
+    return { deleted: path };
+}
+function parseProfileSaveArgs(argsInput) {
+    try {
+        return profileSaveArgsSchema.parse(argsInput);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new ConfigError(formatZodIssues(error), {
+                code: "mcp.invalid_arguments",
+                retryable: false,
+                fix: "Fix the tool arguments and retry."
+            });
+        }
+        throw error;
+    }
+}
+function formatZodIssues(error) {
+    return error.issues.map((issue) => (issue.path.length > 0 ? `${issue.path.join(".")}: ${issue.message}` : issue.message)).join("; ");
+}
+function redactedProfile(value) {
+    const serialized = JSON.stringify(value, (key, inner) => {
+        if (SECRET_KEY_RE.test(key) && inner)
+            return "[redacted]";
+        return inner;
+    });
+    return serialized === undefined ? undefined : JSON.parse(serialized);
+}
+async function saveMcpProfileBundle(name, bundle, force) {
+    assertMcpProfileName(name);
+    rejectRawApiKeyFields(bundle, name);
+    rejectAllSecretShapedFields(bundle, name);
+    validateNamedProfileBundle(bundle, name);
+    const dir = profilesDir();
+    const target = profilePath(name);
+    await mkdir(dir, { recursive: true });
+    if (existsSync(target) && !force) {
+        throw new ConfigError(`Named profile '${name}' already exists at ${target}.`, {
+            code: "config.profile_exists",
+            retryable: false,
+            fix: "Pass force: true to overwrite it."
+        });
+    }
+    const yaml = YAML.stringify(bundle);
+    if (force) {
+        await writeMcpProfileOverwrite(target, yaml, name);
+    }
+    else {
+        await writeMcpProfileCreate(target, yaml, name);
+    }
+    return target;
+}
+function assertMcpProfileName(name) {
+    if (!NAMED_PROFILE_NAME_RE.test(name)) {
+        throw new ConfigError(`Invalid profile name '${name}'. Names must start with a letter and contain only letters, digits, hyphens, and underscores (max 64 chars).`, {
+            code: "config.profile_invalid_name",
+            retryable: false,
+            fix: "Rename the profile to match /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/."
+        });
+    }
+}
+async function writeMcpProfileCreate(target, yaml, name) {
+    try {
+        await writeFile(target, yaml, { encoding: "utf8", flag: "wx" });
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            throw new ConfigError(`Named profile '${name}' already exists at ${target}.`, {
+                code: "config.profile_exists",
+                retryable: false,
+                fix: "Pass force: true to overwrite it."
+            });
+        }
+        throw error;
+    }
+}
+async function writeMcpProfileOverwrite(target, yaml, name) {
+    const tempPath = join(dirname(target), `.${name}.${randomUUID()}.tmp`);
+    await writeFile(tempPath, yaml, { encoding: "utf8", flag: "wx" });
+    try {
+        await rename(tempPath, target);
+    }
+    catch (error) {
+        await unlink(tempPath).catch(() => undefined);
+        throw error;
+    }
+}
+function stripUndefined(value) {
+    if (Array.isArray(value))
+        return value.map(stripUndefined);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, inner]) => inner !== undefined)
+        .map(([key, inner]) => [key, stripUndefined(inner)]));
+}
 //# sourceMappingURL=tools.js.map