abelworkflow 1.2.4 → 1.3.0

package/lib/installer/links.mjs

@@ -228,29 +228,6 @@ async function ensureProviderRootDirectory(homeDir, segments, options = {}) {
   return directory;
 }
 
-async function getDirectoryNames(root) {
-  if (!(await pathIsDirectory(root))) return [];
-  const entries = await fs.readdir(root, { withFileTypes: true });
-  const names = await Promise.all(entries.map(async (entry) => {
-    if (entry.isDirectory()) return entry.name;
-    if (entry.isSymbolicLink() && await pathIsDirectory(join(root, entry.name))) return entry.name;
-    return null;
-  }));
-  return names.filter(Boolean);
-}
-
-async function getCommandNames(commandsDir) {
-  if (!(await pathIsDirectory(commandsDir))) return [];
-  const entries = await fs.readdir(commandsDir, { withFileTypes: true });
-  const names = await Promise.all(entries.map(async (entry) => {
-    if (!entry.name.endsWith(".md")) return null;
-    if (entry.isFile()) return entry.name;
-    if (entry.isSymbolicLink() && await pathIsFile(join(commandsDir, entry.name))) return entry.name;
-    return null;
-  }));
-  return names.filter(Boolean);
-}
-
 async function getPiExtensionNames(extensionsDir) {
   if (!(await pathIsDirectory(extensionsDir))) return [];
   const entries = await fs.readdir(extensionsDir, { withFileTypes: true });
@@ -289,10 +266,48 @@ async function pruneManagedTargets(targetDir, managedSourceRoot, expectedNames,
   return results;
 }
 
-async function linkSkillDirectories(baseDir, paths, previousLinkedTargets, options) {
+const cadenceOwnedSkills = new Set(["grok-search", "context7-auto-research"]);
+
+function shouldLinkSkillToPi(skillName) {
+  return skillName !== ".system"
+    && !skillName.startsWith("abel-")
+    && !cadenceOwnedSkills.has(skillName);
+}
+
+function managedSkillNames(managedFiles = {}) {
+  const names = new Set();
+  for (const relativePath of Object.keys(managedFiles)) {
+    if (!relativePath.startsWith("skills/")) continue;
+    const skillName = relativePath.slice("skills/".length).split("/")[0];
+    if (shouldLinkSkillToPi(skillName)) names.add(skillName);
+  }
+  return names;
+}
+
+function selectedLinkedSkillNames({
+  previousLinkedTargets = {},
+  skillsRoot,
+  managedFiles,
+  extraName = null
+} = {}) {
+  const names = managedFiles ? managedSkillNames(managedFiles) : new Set();
+  if (!managedFiles && skillsRoot) {
+    const resolvedSkillsRoot = resolve(skillsRoot);
+    for (const previousState of Object.values(previousLinkedTargets)) {
+      if (!previousState || previousState.kind !== "dir") continue;
+      const sourcePath = resolve(previousState.sourcePath);
+      if (dirname(sourcePath) !== resolvedSkillsRoot) continue;
+      const skillName = basename(sourcePath);
+      if (shouldLinkSkillToPi(skillName)) names.add(skillName);
+    }
+  }
+  if (extraName && shouldLinkSkillToPi(extraName)) names.add(extraName);
+  return [...names];
+}
+
+async function linkSkillDirectories(baseDir, paths, previousLinkedTargets, options, skillNames) {
   const results = [];
   const skillsRoot = join(paths.agentsDir, "skills");
-  const skillNames = (await getDirectoryNames(skillsRoot)).filter((skillName) => skillName !== ".system");
   results.push(...await pruneManagedTargets(
     join(baseDir, "skills"),
     skillsRoot,
@@ -312,57 +327,54 @@ async function linkSkillDirectories(baseDir, paths, previousLinkedTargets, optio
   return results;
 }
 
-async function linkCommands(targetDir, paths, previousLinkedTargets, options) {
-  const commandsRoot = join(paths.agentsDir, "commands");
-  const commandFiles = await getCommandNames(commandsRoot);
-  const results = await pruneManagedTargets(targetDir, commandsRoot, commandFiles, previousLinkedTargets, options);
-  for (const fileName of commandFiles) {
-    recordLinkResult(results, options, await ensureManagedLink(
-      join(targetDir, fileName),
-      join(commandsRoot, fileName),
-      "file",
+async function linkPiSkill(paths, skillName, previousLinkedTargets = {}, options = {}) {
+  if (!shouldLinkSkillToPi(skillName)) return [];
+  const piAgentDir = await ensureProviderRootDirectory(paths.homeDir, [".pi", "agent"], options);
+  await ensureManagedContainerDirectories([join(piAgentDir, "skills")], options);
+  const skillsRoot = join(paths.agentsDir, "skills");
+  return linkSkillDirectories(
+    piAgentDir,
+    paths,
+    previousLinkedTargets,
+    options,
+    selectedLinkedSkillNames({
       previousLinkedTargets,
-      options
-    ));
-  }
-  return results;
+      skillsRoot,
+      managedFiles: options.managedFiles,
+      extraName: skillName
+    })
+  );
 }
 
-async function linkClaude(paths, previousLinkedTargets = {}, options = {}) {
-  const claudeDir = await ensureProviderRootDirectory(paths.homeDir, [".claude"], options);
-  await ensureManagedContainerDirectories([
-    join(claudeDir, "commands"),
-    join(claudeDir, "skills")
-  ], options);
-  const results = [];
-  recordLinkResult(results, options, await ensureManagedLink(
-    join(claudeDir, "CLAUDE.md"),
-    join(paths.agentsDir, "AGENTS.md"),
-    "file",
-    previousLinkedTargets,
-    options
-  ));
-  results.push(...await linkCommands(join(claudeDir, "commands"), paths, previousLinkedTargets, options));
-  results.push(...await linkSkillDirectories(claudeDir, paths, previousLinkedTargets, options));
-  return results;
+async function pruneProviderInstructions(baseDir, commandsName, paths, previousLinkedTargets, options) {
+  const cleanupOptions = {
+    ...options,
+    validateTargetDir: (directory) => ensureManagedContainerDirectories([directory], options)
+  };
+  return [
+    ...await pruneManagedTargets(baseDir, paths.agentsDir, [], previousLinkedTargets, cleanupOptions),
+    ...await pruneManagedTargets(join(baseDir, commandsName), join(paths.agentsDir, "commands"), [], previousLinkedTargets, cleanupOptions)
+  ];
 }
 
-async function linkCodex(paths, previousLinkedTargets = {}, options = {}) {
-  const codexDir = await ensureProviderRootDirectory(paths.homeDir, [".codex"], options);
-  await ensureManagedContainerDirectories([
-    join(codexDir, "skills"),
-    join(codexDir, "prompts")
-  ], options);
+async function pruneRetiredProviderLinks(paths, previousLinkedTargets = {}, options = {}) {
   const results = [];
-  recordLinkResult(results, options, await ensureManagedLink(
-    join(codexDir, "AGENTS.md"),
-    join(paths.agentsDir, "AGENTS.md"),
-    "file",
-    previousLinkedTargets,
-    options
-  ));
-  results.push(...await linkSkillDirectories(codexDir, paths, previousLinkedTargets, options));
-  results.push(...await linkCommands(join(codexDir, "prompts"), paths, previousLinkedTargets, options));
+  for (const targetDir of [
+    join(paths.homeDir, ".claude"),
+    join(paths.homeDir, ".claude", "commands"),
+    join(paths.homeDir, ".claude", "skills"),
+    join(paths.homeDir, ".codex"),
+    join(paths.homeDir, ".codex", "prompts"),
+    join(paths.homeDir, ".codex", "skills")
+  ]) {
+    results.push(...await pruneManagedTargets(
+      targetDir,
+      paths.agentsDir,
+      [],
+      previousLinkedTargets,
+      options
+    ));
+  }
   return results;
 }
 
@@ -404,19 +416,21 @@ async function linkPi(paths, previousLinkedTargets = {}, options = {}) {
   const piAgentDir = await ensureProviderRootDirectory(paths.homeDir, [".pi", "agent"], options);
   await ensureManagedContainerDirectories([
     join(piAgentDir, "extensions"),
-    join(piAgentDir, "skills"),
-    join(piAgentDir, "prompts")
+    join(piAgentDir, "skills")
   ], options);
-  const results = [];
-  recordLinkResult(results, options, await ensureManagedLink(
-    join(piAgentDir, "AGENTS.md"),
-    join(paths.agentsDir, "AGENTS.md"),
-    "file",
+  const results = await pruneRetiredProviderLinks(paths, previousLinkedTargets, options);
+  results.push(...await pruneProviderInstructions(piAgentDir, "prompts", paths, previousLinkedTargets, options));
+  results.push(...await linkSkillDirectories(
+    piAgentDir,
+    paths,
     previousLinkedTargets,
-    options
+    options,
+    selectedLinkedSkillNames({
+      previousLinkedTargets,
+      skillsRoot: join(paths.agentsDir, "skills"),
+      managedFiles: options.managedFiles
+    })
   ));
-  results.push(...await linkSkillDirectories(piAgentDir, paths, previousLinkedTargets, options));
-  results.push(...await linkCommands(join(piAgentDir, "prompts"), paths, previousLinkedTargets, options));
   results.push(...await linkPiExtensionsInDirectory(
     join(piAgentDir, "extensions"),
     join(paths.agentsDir, "extensions"),
@@ -429,11 +443,10 @@ async function linkPi(paths, previousLinkedTargets = {}, options = {}) {
 export {
   ensureManagedLink,
   ensureProviderRootDirectory,
-  getCommandNames,
   isWithinManagedRoot,
-  linkClaude,
-  linkCodex,
   linkPi,
   linkPiExtensions,
-  pruneManagedTargets
+  linkPiSkill,
+  pruneManagedTargets,
+  shouldLinkSkillToPi
 };

package/lib/paths.mjs

@@ -16,13 +16,11 @@ function createPaths({
   assertSeparateSourceAndDeployment(absolutePackageRoot, absoluteAgentsDir);
 
   const codexTemplateRoot = join(absolutePackageRoot, "lib", "templates", "codex");
-  const workflowTemplateRoot = join(absolutePackageRoot, "lib", "templates", "workflow");
   const piAgentDir = join(absoluteHomeDir, ".pi", "agent");
   return {
     homeDir: absoluteHomeDir,
     packageRoot: absolutePackageRoot,
     agentsDir: absoluteAgentsDir,
-    workflowTemplateRoot,
     installMetadataName: ".abelworkflow-install.json",
     claudeSettingsPath: join(absoluteHomeDir, ".claude", "settings.json"),
     codexConfigPath: join(absoluteHomeDir, ".codex", "config.toml"),

package/lib/providers/claude.mjs

@@ -50,8 +50,15 @@ const defaultClaudeSettings = {
   language: "Chinese"
 };
 
+function assertClaudeApiKey(value, label) {
+  if (value !== undefined && typeof value !== "string") {
+    throw new TypeError(`${label} must be a string or undefined`);
+  }
+}
+
 function getExistingClaudeApiConfig(settings) {
   const env = settings.env === undefined ? {} : assertPlainObject(settings.env, "Claude settings env");
+  assertClaudeApiKey(env.ANTHROPIC_API_KEY, "Claude settings env ANTHROPIC_API_KEY");
   return {
     baseUrl: env.ANTHROPIC_BASE_URL || "https://api.anthropic.com",
     key: env.ANTHROPIC_API_KEY || "",
@@ -66,6 +73,8 @@ function buildClaudeApiSettings(settings, {
 }) {
   assertPlainObject(settings, "Claude settings");
   const env = settings.env === undefined ? {} : assertPlainObject(settings.env, "Claude settings env");
+  assertClaudeApiKey(env.ANTHROPIC_API_KEY, "Claude settings env ANTHROPIC_API_KEY");
+  assertClaudeApiKey(key, "Claude API key");
   const permissions = settings.permissions === undefined
     ? {}
     : assertPlainObject(settings.permissions, "Claude settings permissions");
@@ -82,8 +91,7 @@ function buildClaudeApiSettings(settings, {
     env: {
       ...defaultClaudeSettings.env,
       ...env,
-      ANTHROPIC_BASE_URL: normalizeHttpBaseUrl(baseUrl),
-      ANTHROPIC_API_KEY: key
+      ANTHROPIC_BASE_URL: normalizeHttpBaseUrl(baseUrl)
     },
     permissions: {
       ...defaultClaudeSettings.permissions,
@@ -92,6 +100,8 @@ function buildClaudeApiSettings(settings, {
       deny: Array.isArray(permissions.deny) ? permissions.deny : [...defaultClaudeSettings.permissions.deny]
     }
   };
+  if (key === undefined) delete nextSettings.env.ANTHROPIC_API_KEY;
+  else nextSettings.env.ANTHROPIC_API_KEY = key;
   delete nextSettings.includeCoAuthoredBy;
   delete nextSettings.env.ANTHROPIC_AUTH_TOKEN;
   delete nextSettings.env.DISABLE_TELEMETRY;
@@ -144,7 +154,8 @@ async function configureClaudeApi(paths, promptApi, runtime = {}) {
 
   const finalKey = await passwordOrExisting({
     message: "Claude Code API Key",
-    existingValue: existing.key
+    existingValue: existing.key,
+    requiredMessage: existing.key ? null : "API Key 不能为空"
   });
 
   const model = await text({

package/lib/providers/codex.mjs

@@ -62,7 +62,10 @@ function mergeCodexTemplateDefaults(content, templateContent) {
     ? current.developer_instructions
     : "";
 
-  if (publishedCodexDeveloperInstructionHashes.has(hashBytes(currentInstructions))) {
+  const instructionHash = hashBytes(currentInstructions);
+  const usesLegacyDefaults = publishedCodexDeveloperInstructionHashes.has(instructionHash);
+  if (usesLegacyDefaults
+    || instructionHash === "c84017d17fa425175f6dd7df9766b5de74e289420f63fea87054e2f41822a8bc") {
     const legacyDefaults = {
       approvals_reviewer: "guardian_subagent",
       approval_policy: "on-request",
@@ -71,7 +74,7 @@ function mergeCodexTemplateDefaults(content, templateContent) {
     };
     const replacementFields = new Set(["developer_instructions"]);
     for (const [field, value] of Object.entries(legacyDefaults)) {
-      if (current[field] === value) replacementFields.add(field);
+      if (usesLegacyDefaults && current[field] === value) replacementFields.add(field);
     }
     for (const field of replacementFields) {
       nextContent = removeTopLevelTomlField(nextContent, field);
@@ -375,15 +378,17 @@ function buildCodexConfigContent(currentContent, {
 
 function mergeCodexAuthData(auth, apiKey) {
   assertPlainObject(auth, "Codex auth");
-  const nextAuth = { ...auth };
-  assertCodexAuthKeyAvailable(nextAuth, CODEX_ENV_KEY);
+  assertCodexAuthKeyAvailable(auth, CODEX_ENV_KEY);
   if (apiKey) {
-    nextAuth.auth_mode = "apikey";
-    nextAuth[CODEX_ENV_KEY] = apiKey;
-  } else {
-    delete nextAuth[CODEX_ENV_KEY];
-    if (nextAuth.auth_mode === "apikey") delete nextAuth.auth_mode;
+    return {
+      auth_mode: "apikey",
+      [CODEX_ENV_KEY]: apiKey
+    };
   }
+
+  const nextAuth = { ...auth };
+  delete nextAuth[CODEX_ENV_KEY];
+  if (nextAuth.auth_mode === "apikey") delete nextAuth.auth_mode;
   return nextAuth;
 }
 

package/lib/providers/pi.mjs

@@ -5,7 +5,11 @@ import {
   readJsoncFileSafe,
   withFileTransaction
 } from "../config/store.mjs";
-import { normalizeOpenAiBaseUrl } from "./url.mjs";
+import {
+  normalizeOpenAiBaseUrl,
+  promptBaseUrlOptions,
+  resolvePromptedBaseUrl
+} from "./url.mjs";
 import { stripJsonComments } from "../config/jsonc.mjs";
 
 const piProviderId = "abelworkflow";
@@ -349,83 +353,72 @@ async function persistPiConfiguration(paths, intent, operations = {}) {
   });
 }
 
-async function configurePiApi(paths, withExtensionsPresent, promptApi, runtime = {}) {
-  if (typeof withExtensionsPresent !== "function") {
-    throw new TypeError("Expected a Pi Extensions deployment function");
-  }
-  return withExtensionsPresent(paths, async (guard) => {
-    await guard();
-    const text = runtime.text ?? p.text;
-    const {
-      assertNotCancelled,
-      passwordOrExisting,
-      selectOrCancel
-    } = promptApi;
-    const { auth, models, settings } = await readExistingPiConfiguration(paths);
-    const existing = resolveExistingPiApiConfig(models, settings, auth);
-    const providerLabel = `Pi ${piProviderId}`;
-
-    const baseUrlInput = await text({
-      message: `${providerLabel} Base URL`,
-      initialValue: existing.baseUrl || undefined,
-      validate: (value) => {
-        try {
-          normalizeOpenAiBaseUrl(value);
-        } catch (error) {
-          return error.message;
-        }
-      }
-    });
-    assertNotCancelled(baseUrlInput);
-    const inferredApi = inferPiApiFromBaseUrl(baseUrlInput);
-    const baseUrl = normalizeOpenAiBaseUrl(baseUrlInput);
+async function promptPiConfiguration(paths, promptApi, runtime = {}) {
+  const text = runtime.text ?? p.text;
+  const {
+    assertNotCancelled,
+    passwordOrExisting,
+    selectOrCancel
+  } = promptApi;
+  const { auth, models, settings } = await readExistingPiConfiguration(paths);
+  const existing = resolveExistingPiApiConfig(models, settings, auth);
+  const providerLabel = `Pi ${piProviderId}`;
 
-    const apiOptions = getPiApiPromptOptions();
-    const initialApi = apiOptions.some((option) => option.value === existing.api)
-      ? existing.api
-      : undefined;
-    const api = inferredApi || await selectOrCancel({
-      message: `${providerLabel} API 类型`,
-      options: apiOptions,
-      ...(initialApi ? { initialValue: initialApi } : {})
-    });
-    const apiKey = await passwordOrExisting({
-      message: `${providerLabel} API Key`,
-      existingValue: existing.apiKey
-    });
+  const baseUrlPrompt = {
+    message: `${providerLabel} Base URL`,
+    existingValue: existing.baseUrl,
+    placeholder: "https://api.openai.com/v1",
+    normalize: normalizeOpenAiBaseUrl
+  };
+  const baseUrlInput = await text(promptBaseUrlOptions(baseUrlPrompt));
+  assertNotCancelled(baseUrlInput);
+  const inferredApi = inferPiApiFromBaseUrl(baseUrlInput);
+  const baseUrl = resolvePromptedBaseUrl(baseUrlInput, baseUrlPrompt);
 
-    const modelIdsText = await text({
-      message: `${providerLabel} 模型 ID（多个用逗号分隔）`,
-      initialValue: existing.modelIds.join(",") || undefined,
-      validate: (value) => parsePiModelIds(value).length ? undefined : "至少需要一个模型 ID"
-    });
-    assertNotCancelled(modelIdsText);
-    const modelIds = parsePiModelIds(modelIdsText);
-    const defaultModel = await text({
-      message: "Pi 默认模型",
-      initialValue: modelIds.includes(existing.defaultModel) ? existing.defaultModel : modelIds[0],
-      validate: (value) => modelIds.includes(String(value || "").trim())
-        ? undefined
-        : "默认模型必须在模型 ID 列表中"
-    });
-    assertNotCancelled(defaultModel);
+  const apiOptions = getPiApiPromptOptions();
+  const initialApi = apiOptions.some((option) => option.value === existing.api)
+    ? existing.api
+    : undefined;
+  const api = inferredApi || await selectOrCancel({
+    message: `${providerLabel} API 类型`,
+    options: apiOptions,
+    ...(initialApi ? { initialValue: initialApi } : {})
+  });
+  const apiKey = await passwordOrExisting({
+    message: `${providerLabel} API Key`,
+    existingValue: existing.apiKey
+  });
 
-    await guard();
-    await persistPiConfiguration(paths, {
-      apiKey,
-      baseUrl,
-      api,
-      modelIds,
-      defaultModel: String(defaultModel).trim()
-    });
+  const modelIdsText = await text({
+    message: `${providerLabel} 模型 ID（多个用逗号分隔）`,
+    initialValue: existing.modelIds.join(",") || undefined,
+    validate: (value) => parsePiModelIds(value).length ? undefined : "至少需要一个模型 ID"
+  });
+  assertNotCancelled(modelIdsText);
+  const modelIds = parsePiModelIds(modelIdsText);
+  const defaultModel = await text({
+    message: "Pi 默认模型",
+    initialValue: modelIds.includes(existing.defaultModel) ? existing.defaultModel : modelIds[0],
+    validate: (value) => modelIds.includes(String(value || "").trim())
+      ? undefined
+      : "默认模型必须在模型 ID 列表中"
   });
+  assertNotCancelled(defaultModel);
+
+  return {
+    apiKey,
+    baseUrl,
+    api,
+    modelIds,
+    defaultModel: String(defaultModel).trim()
+  };
 }
 
 export {
   buildPiAuthConfig,
   buildPiModelsConfig,
   buildPiSettingsConfig,
-  configurePiApi,
+  promptPiConfiguration,
   getPiApiPromptOptions,
   inferPiApiFromBaseUrl,
   normalizeOpenAiBaseUrl,

package/lib/providers/skills.mjs

@@ -3,7 +3,11 @@ import { join } from "node:path";
 import * as p from "@clack/prompts";
 import { readDotenvFile, updateDotenvFile } from "../config/store.mjs";
 import { pathToLabel } from "../paths.mjs";
-import { normalizeHttpBaseUrl } from "./url.mjs";
+import {
+  normalizeHttpBaseUrl,
+  promptBaseUrlOptions,
+  resolvePromptedBaseUrl
+} from "./url.mjs";
 
 const grokDefaults = Object.freeze(JSON.parse(readFileSync(
   new URL("../../skills/grok-search/defaults.json", import.meta.url),
@@ -18,14 +22,6 @@ async function updateSkillEnvFile(path, updates, safeRoot) {
   return updateDotenvFile(path, updates, { safeRoot, sensitive: true });
 }
 
-function validateHttpBaseUrl(value) {
-  try {
-    normalizeHttpBaseUrl(value);
-  } catch (error) {
-    return error.message;
-  }
-}
-
 async function configureGrokSearchEnv(paths, withSkillPresent, promptApi, runtime = {}) {
   const {
     assertNotCancelled,
@@ -39,13 +35,21 @@ async function configureGrokSearchEnv(paths, withSkillPresent, promptApi, runtim
     await guard();
     const envPath = join(paths.agentsDir, "skills", "grok-search", ".env");
     const existing = await readSkillEnvFile(envPath, paths.agentsDir);
-    const baseUrlInput = await text({
+    const grokApiUrlPrompt = {
       message: "Grok API URL",
-      initialValue: existing.GROK_API_URL || "https://api.x.ai/v1",
-      validate: validateHttpBaseUrl
-    });
+      existingValue: existing.GROK_API_URL,
+      placeholder: "https://api.x.ai/v1",
+      normalize: normalizeHttpBaseUrl
+    };
+    const tavilyApiUrlPrompt = {
+      message: "Tavily API URL",
+      existingValue: existing.TAVILY_API_URL,
+      placeholder: "https://api.tavily.com",
+      normalize: normalizeHttpBaseUrl
+    };
+    const baseUrlInput = await text(promptBaseUrlOptions(grokApiUrlPrompt));
     assertNotCancelled(baseUrlInput);
-    const baseUrl = normalizeHttpBaseUrl(baseUrlInput);
+    const baseUrl = resolvePromptedBaseUrl(baseUrlInput, grokApiUrlPrompt);
 
     const finalApiKey = await passwordOrExisting({
       message: "Grok API Key",
@@ -65,15 +69,11 @@ async function configureGrokSearchEnv(paths, withSkillPresent, promptApi, runtim
       initialValue: Boolean(existing.TAVILY_API_KEY)
     });
 
-    const tavilyUrl = useTavily
-      ? await text({
-          message: "Tavily API URL",
-          initialValue: existing.TAVILY_API_URL || "https://api.tavily.com",
-          validate: validateHttpBaseUrl
-        })
-      : null;
+    const tavilyUrl = useTavily ? await text(promptBaseUrlOptions(tavilyApiUrlPrompt)) : null;
     if (useTavily) assertNotCancelled(tavilyUrl);
-    const normalizedTavilyUrl = useTavily ? normalizeHttpBaseUrl(tavilyUrl) : null;
+    const normalizedTavilyUrl = useTavily
+      ? resolvePromptedBaseUrl(tavilyUrl, tavilyApiUrlPrompt)
+      : null;
 
     const finalTavilyKey = useTavily
       ? await passwordOrExisting({

package/lib/providers/url.mjs

@@ -32,4 +32,35 @@ function normalizeOpenAiBaseUrl(value) {
   return url.toString();
 }
 
-export { normalizeHttpBaseUrl, normalizeOpenAiBaseUrl };
+function resolvePromptedBaseUrl(value, { existingValue = "", placeholder, normalize }) {
+  const existing = typeof existingValue === "string" ? existingValue.trim() : "";
+  return normalize(String(value || "").trim() || existing || placeholder);
+}
+
+function promptBaseUrlOptions({
+  message,
+  existingValue,
+  placeholder,
+  normalize
+}) {
+  const existing = typeof existingValue === "string" ? existingValue.trim() : "";
+  return {
+    message,
+    placeholder,
+    ...(existing ? { initialValue: existing } : { defaultValue: placeholder }),
+    validate(value) {
+      try {
+        resolvePromptedBaseUrl(value, { existingValue: existing, placeholder, normalize });
+      } catch (error) {
+        return error.message;
+      }
+    }
+  };
+}
+
+export {
+  normalizeHttpBaseUrl,
+  normalizeOpenAiBaseUrl,
+  promptBaseUrlOptions,
+  resolvePromptedBaseUrl
+};