create-mastra 0.0.0-netlify-no-bundle-20251127120354 → 0.0.0-partial-response-backport-20251204204441

package/dist/index.js

@@ -4,7 +4,7 @@ import { randomUUID } from 'node:crypto';
 import * as fs3__default from 'node:fs';
 import fs3__default__default, { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
-import path3, { dirname } from 'node:path';
+import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { PostHog } from 'posthog-node';
 import fs4 from 'node:fs/promises';
@@ -23,7 +23,7 @@ import pretty from 'pino-pretty';
 import fsExtra$1 from 'fs-extra';
 
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
+var __dirname = path.dirname(__filename);
 var analyticsInstance = null;
 function getAnalytics() {
   return analyticsInstance;
@@ -39,7 +39,7 @@ var PosthogAnalytics = class {
     host = "https://app.posthog.com"
   }) {
     this.version = version;
-    const cliConfigPath = path3.join(__dirname, "mastra-cli.json");
+    const cliConfigPath = path.join(__dirname, "mastra-cli.json");
     if (existsSync(cliConfigPath)) {
       try {
         const { distinctId, sessionId } = JSON.parse(readFileSync(cliConfigPath, "utf-8"));
@@ -67,7 +67,7 @@ var PosthogAnalytics = class {
   }
   writeCliConfig({ distinctId, sessionId }) {
     try {
-      writeFileSync(path3.join(__dirname, "mastra-cli.json"), JSON.stringify({ distinctId, sessionId }));
+      writeFileSync(path.join(__dirname, "mastra-cli.json"), JSON.stringify({ distinctId, sessionId }));
     } catch {
     }
   }
@@ -887,7 +887,6 @@ class YoctoSpinner {
 	#exitHandlerBound;
 	#isInteractive;
 	#lastSpinnerFrameTime = 0;
-	#isSpinning = false;
 
 	constructor(options = {}) {
 		const spinner = options.spinner ?? defaultSpinner;
@@ -909,17 +908,13 @@ class YoctoSpinner {
 			return this;
 		}
 
-		this.#isSpinning = true;
 		this.#hideCursor();
 		this.#render();
 		this.#subscribeToProcessEvents();
 
-		// Only start the timer in interactive mode
-		if (this.#isInteractive) {
-			this.#timer = setInterval(() => {
-				this.#render();
-			}, this.#interval);
-		}
+		this.#timer = setInterval(() => {
+			this.#render();
+		}, this.#interval);
 
 		return this;
 	}
@@ -929,12 +924,8 @@ class YoctoSpinner {
 			return this;
 		}
 
-		this.#isSpinning = false;
-		if (this.#timer) {
-			clearInterval(this.#timer);
-			this.#timer = undefined;
-		}
-
+		clearInterval(this.#timer);
+		this.#timer = undefined;
 		this.#showCursor();
 		this.clear();
 		this.#unsubscribeFromProcessEvents();
@@ -967,7 +958,7 @@ class YoctoSpinner {
 	}
 
 	get isSpinning() {
-		return this.#isSpinning;
+		return this.#timer !== undefined;
 	}
 
 	get text() {
@@ -1104,11 +1095,11 @@ var MastraLogger = class {
   }
   trackException(_error) {
   }
-  async listLogs(transportId, params) {
+  async getLogs(transportId, params) {
     if (!transportId || !this.transports.has(transportId)) {
       return { logs: [], total: 0, page: params?.page ?? 1, perPage: params?.perPage ?? 100, hasMore: false };
     }
-    return this.transports.get(transportId).listLogs(params) ?? {
+    return this.transports.get(transportId).getLogs(params) ?? {
       logs: [],
       total: 0,
       page: params?.page ?? 1,
@@ -1116,7 +1107,7 @@ var MastraLogger = class {
       hasMore: false
     };
   }
-  async listLogsByRunId({
+  async getLogsByRunId({
     transportId,
     runId,
     fromDate,
@@ -1129,7 +1120,7 @@ var MastraLogger = class {
     if (!transportId || !this.transports.has(transportId) || !runId) {
       return { logs: [], total: 0, page: page ?? 1, perPage: perPage ?? 100, hasMore: false };
     }
-    return this.transports.get(transportId).listLogsByRunId({ runId, fromDate, toDate, logLevel, filters, page, perPage }) ?? {
+    return this.transports.get(transportId).getLogsByRunId({ runId, fromDate, toDate, logLevel, filters, page, perPage }) ?? {
       logs: [],
       total: 0,
       page: page ?? 1,
@@ -1187,8 +1178,118 @@ var PinoLogger = class extends MastraLogger {
   }
 };
 
-var package_default = {
-  version: "1.0.0-beta.4"};
+var args = ["-y", "@mastra/mcp-docs-server"];
+var createMcpConfig = (editor) => {
+  if (editor === "vscode") {
+    return {
+      servers: {
+        mastra: process.platform === `win32` ? {
+          command: "cmd",
+          args: ["/c", "npx", ...args],
+          type: "stdio"
+        } : {
+          command: "npx",
+          args,
+          type: "stdio"
+        }
+      }
+    };
+  }
+  return {
+    mcpServers: {
+      mastra: {
+        command: "npx",
+        args
+      }
+    }
+  };
+};
+function makeConfig(original, editor) {
+  if (editor === "vscode") {
+    return {
+      ...original,
+      servers: {
+        ...original?.servers || {},
+        ...createMcpConfig(editor).servers
+      }
+    };
+  }
+  return {
+    ...original,
+    mcpServers: {
+      ...original?.mcpServers || {},
+      ...createMcpConfig(editor).mcpServers
+    }
+  };
+}
+async function writeMergedConfig(configPath, editor) {
+  const configExists = existsSync(configPath);
+  const config = makeConfig(configExists ? await readJSON(configPath) : {}, editor);
+  await ensureFile(configPath);
+  await writeJSON(configPath, config, {
+    spaces: 2
+  });
+}
+var windsurfGlobalMCPConfigPath = path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
+var cursorGlobalMCPConfigPath = path.join(os.homedir(), ".cursor", "mcp.json");
+path.join(process.cwd(), ".vscode", "mcp.json");
+var vscodeGlobalMCPConfigPath = path.join(
+  os.homedir(),
+  process.platform === "win32" ? path.join("AppData", "Roaming", "Code", "User", "settings.json") : process.platform === "darwin" ? path.join("Library", "Application Support", "Code", "User", "settings.json") : path.join(".config", "Code", "User", "settings.json")
+);
+async function installMastraDocsMCPServer({ editor, directory }) {
+  if (editor === `cursor`) {
+    await writeMergedConfig(path.join(directory, ".cursor", "mcp.json"), "cursor");
+  }
+  if (editor === `vscode`) {
+    await writeMergedConfig(path.join(directory, ".vscode", "mcp.json"), "vscode");
+  }
+  if (editor === `cursor-global`) {
+    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
+    if (alreadyInstalled) {
+      return;
+    }
+    await writeMergedConfig(cursorGlobalMCPConfigPath, "cursor-global");
+  }
+  if (editor === `windsurf`) {
+    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor);
+    if (alreadyInstalled) {
+      return;
+    }
+    await writeMergedConfig(windsurfGlobalMCPConfigPath, editor);
+  }
+}
+async function globalMCPIsAlreadyInstalled(editor) {
+  let configPath = ``;
+  if (editor === "windsurf") {
+    configPath = windsurfGlobalMCPConfigPath;
+  } else if (editor === "cursor-global") {
+    configPath = cursorGlobalMCPConfigPath;
+  } else if (editor === "vscode") {
+    configPath = vscodeGlobalMCPConfigPath;
+  }
+  if (!configPath || !existsSync(configPath)) {
+    return false;
+  }
+  try {
+    const configContents = await readJSON(configPath);
+    if (!configContents) return false;
+    if (editor === "vscode") {
+      if (!configContents.servers) return false;
+      const hasMastraMCP2 = Object.values(configContents.servers).some(
+        (server) => server?.args?.find((arg) => arg?.includes(`@mastra/mcp-docs-server`))
+      );
+      return hasMastraMCP2;
+    }
+    if (!configContents?.mcpServers) return false;
+    const hasMastraMCP = Object.values(configContents.mcpServers).some(
+      (server) => server?.args?.find((arg) => arg?.includes(`@mastra/mcp-docs-server`))
+    );
+    return hasMastraMCP;
+  } catch {
+    return false;
+  }
+}
 function getPackageManagerAddCommand(pm) {
   switch (pm) {
     case "npm":
@@ -1211,11 +1312,11 @@ var DepsService = class {
   findLockFile(dir) {
     const lockFiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"];
     for (const file of lockFiles) {
-      if (fs3__default__default.existsSync(path3.join(dir, file))) {
+      if (fs3__default__default.existsSync(path.join(dir, file))) {
         return file;
       }
     }
-    const parentDir = path3.resolve(dir, "..");
+    const parentDir = path.resolve(dir, "..");
     if (parentDir !== dir) {
       return this.findLockFile(parentDir);
     }
@@ -1248,7 +1349,7 @@ var DepsService = class {
   }
   async checkDependencies(dependencies) {
     try {
-      const packageJsonPath = path3.join(process.cwd(), "package.json");
+      const packageJsonPath = path.join(process.cwd(), "package.json");
       try {
         await fs4.access(packageJsonPath);
       } catch {
@@ -1268,7 +1369,7 @@ var DepsService = class {
   }
   async getProjectName() {
     try {
-      const packageJsonPath = path3.join(process.cwd(), "package.json");
+      const packageJsonPath = path.join(process.cwd(), "package.json");
       const packageJson = await fs4.readFile(packageJsonPath, "utf-8");
       const pkg = JSON.parse(packageJson);
       return pkg.name;
@@ -1356,8 +1457,8 @@ var FileService = class {
    */
   async copyStarterFile(inputFile, outputFilePath, replaceIfExists) {
     const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path3.dirname(__filename);
-    const filePath = path3.resolve(__dirname, "starter-files", inputFile);
+    const __dirname = path.dirname(__filename);
+    const filePath = path.resolve(__dirname, "starter-files", inputFile);
     const fileString = fs3__default__default.readFileSync(filePath, "utf8");
     if (fs3__default__default.existsSync(outputFilePath) && !replaceIfExists) {
       console.info(`${outputFilePath} already exists`);
@@ -1367,7 +1468,7 @@ var FileService = class {
     return true;
   }
   async setupEnvFile({ dbUrl }) {
-    const envPath = path3.join(process.cwd(), ".env.development");
+    const envPath = path.join(process.cwd(), ".env.development");
     await fsExtra.ensureFile(envPath);
     const fileEnvService = new FileEnvService(envPath);
     await fileEnvService.setEnvValue("DB_URL", dbUrl);
@@ -1391,142 +1492,21 @@ var FileService = class {
     fs3__default__default.writeFileSync(filePath, fileContent);
   }
 };
-var createArgs = (versionTag) => {
-  const packageName = versionTag ? `@mastra/mcp-docs-server@${versionTag}` : "@mastra/mcp-docs-server";
-  return ["-y", packageName];
-};
-var createMcpConfig = (editor, versionTag) => {
-  const args = createArgs(versionTag);
-  if (editor === "vscode") {
-    return {
-      servers: {
-        mastra: process.platform === `win32` ? {
-          command: "cmd",
-          args: ["/c", "npx", ...args],
-          type: "stdio"
-        } : {
-          command: "npx",
-          args,
-          type: "stdio"
-        }
-      }
-    };
-  }
-  return {
-    mcpServers: {
-      mastra: {
-        command: "npx",
-        args
-      }
-    }
-  };
-};
-function makeConfig(original, editor, versionTag) {
-  if (editor === "vscode") {
-    return {
-      ...original,
-      servers: {
-        ...original?.servers || {},
-        ...createMcpConfig(editor, versionTag).servers
-      }
-    };
-  }
-  return {
-    ...original,
-    mcpServers: {
-      ...original?.mcpServers || {},
-      ...createMcpConfig(editor, versionTag).mcpServers
-    }
-  };
-}
-async function writeMergedConfig(configPath, editor, versionTag) {
-  const configExists = existsSync(configPath);
-  const config = makeConfig(configExists ? await readJSON(configPath) : {}, editor, versionTag);
-  await ensureFile(configPath);
-  await writeJSON(configPath, config, {
-    spaces: 2
-  });
-}
-var windsurfGlobalMCPConfigPath = path3.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
-var cursorGlobalMCPConfigPath = path3.join(os.homedir(), ".cursor", "mcp.json");
-path3.join(process.cwd(), ".vscode", "mcp.json");
-var vscodeGlobalMCPConfigPath = path3.join(
-  os.homedir(),
-  process.platform === "win32" ? path3.join("AppData", "Roaming", "Code", "User", "settings.json") : process.platform === "darwin" ? path3.join("Library", "Application Support", "Code", "User", "settings.json") : path3.join(".config", "Code", "User", "settings.json")
-);
-async function installMastraDocsMCPServer({
-  editor,
-  directory,
-  versionTag
-}) {
-  if (editor === `cursor`) {
-    await writeMergedConfig(path3.join(directory, ".cursor", "mcp.json"), "cursor", versionTag);
-  }
-  if (editor === `vscode`) {
-    await writeMergedConfig(path3.join(directory, ".vscode", "mcp.json"), "vscode", versionTag);
-  }
-  if (editor === `cursor-global`) {
-    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor, versionTag);
-    if (alreadyInstalled) {
-      return;
-    }
-    await writeMergedConfig(cursorGlobalMCPConfigPath, "cursor-global", versionTag);
-  }
-  if (editor === `windsurf`) {
-    const alreadyInstalled = await globalMCPIsAlreadyInstalled(editor, versionTag);
-    if (alreadyInstalled) {
-      return;
-    }
-    await writeMergedConfig(windsurfGlobalMCPConfigPath, editor, versionTag);
-  }
-}
-async function globalMCPIsAlreadyInstalled(editor, versionTag) {
-  let configPath = ``;
-  if (editor === "windsurf") {
-    configPath = windsurfGlobalMCPConfigPath;
-  } else if (editor === "cursor-global") {
-    configPath = cursorGlobalMCPConfigPath;
-  } else if (editor === "vscode") {
-    configPath = vscodeGlobalMCPConfigPath;
-  }
-  if (!configPath || !existsSync(configPath)) {
-    return false;
-  }
-  try {
-    const configContents = await readJSON(configPath);
-    if (!configContents) return false;
-    const expectedPackage = versionTag ? `@mastra/mcp-docs-server@${versionTag}` : "@mastra/mcp-docs-server";
-    if (editor === "vscode") {
-      if (!configContents.servers) return false;
-      const hasMastraMCP2 = Object.values(configContents.servers).some(
-        (server) => server?.args?.find((arg) => arg === expectedPackage)
-      );
-      return hasMastraMCP2;
-    }
-    if (!configContents?.mcpServers) return false;
-    const hasMastraMCP = Object.values(configContents.mcpServers).some(
-      (server) => server?.args?.find((arg) => arg === expectedPackage)
-    );
-    return hasMastraMCP;
-  } catch {
-    return false;
-  }
-}
 var exec = util.promisify(child_process.exec);
 var getModelIdentifier = (llmProvider) => {
-  let model = "openai/gpt-4o";
-  if (llmProvider === "anthropic") {
-    model = "anthropic/claude-sonnet-4-5";
+  if (llmProvider === "openai") {
+    return `'openai/gpt-4o-mini'`;
+  } else if (llmProvider === "anthropic") {
+    return `'anthropic/claude-sonnet-4-5-20250929'`;
   } else if (llmProvider === "groq") {
-    model = "groq/llama-3.3-70b-versatile";
+    return `'groq/llama-3.3-70b-versatile'`;
   } else if (llmProvider === "google") {
-    model = "google/gemini-2.5-pro";
+    return `'google/gemini-2.5-pro'`;
   } else if (llmProvider === "cerebras") {
-    model = "cerebras/llama-3.3-70b";
+    return `'cerebras/llama-3.3-70b'`;
   } else if (llmProvider === "mistral") {
-    model = "mistral/mistral-medium-2508";
+    return `'mistral/mistral-medium-2508'`;
   }
-  return model;
 };
 async function writeAgentSample(llmProvider, destPath, addExampleTool, addScorers) {
   const modelString = getModelIdentifier(llmProvider);
@@ -1552,10 +1532,9 @@ ${addExampleTool ? `import { weatherTool } from '../tools/weather-tool';` : ""}
 ${addScorers ? `import { scorers } from '../scorers/weather-scorer';` : ""}
 
 export const weatherAgent = new Agent({
-  id: 'weather-agent',
   name: 'Weather Agent',
   instructions: \`${instructions}\`,
-  model: '${modelString}',
+  model: ${modelString},
   ${addExampleTool ? "tools: { weatherTool }," : ""}
   ${addScorers ? `scorers: {
     toolCallAppropriateness: {
@@ -1582,7 +1561,6 @@ export const weatherAgent = new Agent({
   },` : ""}
   memory: new Memory({
     storage: new LibSQLStore({
-      id: "memory-storage",
       url: "file:../mastra.db", // path is relative to the .mastra/output directory
     })
   })
@@ -1795,10 +1773,9 @@ async function writeToolSample(destPath) {
 async function writeScorersSample(llmProvider, destPath) {
   const modelString = getModelIdentifier(llmProvider);
   const content = `import { z } from 'zod';
-import { createToolCallAccuracyScorerCode } from '@mastra/evals/scorers/prebuilt';
-import { createCompletenessScorer } from '@mastra/evals/scorers/prebuilt';
-import { getAssistantMessageFromRunOutput, getUserMessageFromRunInput } from '@mastra/evals/scorers/utils';
-import { createScorer } from '@mastra/core/evals';
+import { createToolCallAccuracyScorerCode } from '@mastra/evals/scorers/code';
+import { createCompletenessScorer } from '@mastra/evals/scorers/code';
+import { createScorer } from '@mastra/core/scores';
 
 export const toolCallAppropriatenessScorer = createToolCallAccuracyScorerCode({
   expectedTool: 'weatherTool',
@@ -1809,12 +1786,11 @@ export const completenessScorer = createCompletenessScorer();
 
 // Custom LLM-judged scorer: evaluates if non-English locations are translated appropriately
 export const translationScorer = createScorer({
-  id: 'translation-quality-scorer',
   name: 'Translation Quality',
   description: 'Checks that non-English location names are translated and used correctly',
   type: 'agent',
   judge: {
-    model: '${modelString}',
+    model: ${modelString},
     instructions:
       'You are an expert evaluator of translation quality for geographic locations. ' +
       'Determine whether the user text mentions a non-English location and whether the assistant correctly uses an English translation of that location. ' +
@@ -1823,8 +1799,8 @@ export const translationScorer = createScorer({
   },
 })
   .preprocess(({ run }) => {
-    const userText = getUserMessageFromRunInput(run.input) || '';
-    const assistantText = getAssistantMessageFromRunOutput(run.output) || '';
+    const userText = (run.input?.inputMessages?.[0]?.content as string) || '';
+    const assistantText = (run.output?.[0]?.content as string) || '';
     return { userText, assistantText };
   })
   .analyze({
@@ -1911,7 +1887,7 @@ var writeIndexFile = async ({
   addScorers
 }) => {
   const indexPath = dirPath + "/index.ts";
-  const destPath = path3.join(indexPath);
+  const destPath = path.join(indexPath);
   try {
     await fs4.writeFile(destPath, "");
     const filteredExports = [
@@ -1923,7 +1899,7 @@ var writeIndexFile = async ({
       await fs4.writeFile(
         destPath,
         `
-import { Mastra } from '@mastra/core/mastra';
+import { Mastra } from '@mastra/core';
 
 export const mastra = new Mastra()
         `
@@ -1936,7 +1912,6 @@ export const mastra = new Mastra()
 import { Mastra } from '@mastra/core/mastra';
 import { PinoLogger } from '@mastra/loggers';
 import { LibSQLStore } from '@mastra/libsql';
-import { Observability } from '@mastra/observability';
 ${addWorkflow ? `import { weatherWorkflow } from './workflows/weather-workflow';` : ""}
 ${addAgent ? `import { weatherAgent } from './agents/weather-agent';` : ""}
 ${addScorers ? `import { toolCallAppropriatenessScorer, completenessScorer, translationScorer } from './scorers/weather-scorer';` : ""}
@@ -1944,7 +1919,6 @@ ${addScorers ? `import { toolCallAppropriatenessScorer, completenessScorer, tran
 export const mastra = new Mastra({
   ${filteredExports.join("\n  ")}
   storage: new LibSQLStore({
-    id: "mastra-storage",
     // stores observability, scores, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
@@ -1952,10 +1926,14 @@ export const mastra = new Mastra({
     name: 'Mastra',
     level: 'info',
   }),
-  observability: new Observability({
-    // Enables DefaultExporter and CloudExporter for tracing
-    default: { enabled: true },
-    }),
+  telemetry: {
+    // Telemetry is deprecated and will be removed in the Nov 4th release
+    enabled: false, 
+  },
+  observability: {
+    // Enables DefaultExporter and CloudExporter for AI tracing
+    default: { enabled: true }, 
+  },
 });
 `
     );
@@ -1994,7 +1972,7 @@ var writeAPIKey = async ({ provider, apiKey }) => {
 };
 var createMastraDir = async (directory) => {
   let dir = directory.trim().split("/").filter((item) => item !== "");
-  const dirPath = path3.join(process.cwd(), ...dir, "mastra");
+  const dirPath = path.join(process.cwd(), ...dir, "mastra");
   try {
     await fs4.access(dirPath);
     return { ok: false };
@@ -2019,8 +1997,8 @@ var LLM_PROVIDERS = [
   { value: "cerebras", label: "Cerebras" },
   { value: "mistral", label: "Mistral" }
 ];
-var interactivePrompt = async (args = {}) => {
-  const { skip = {}, options: { showBanner = true } = {} } = args;
+var interactivePrompt = async (args2 = {}) => {
+  const { skip = {}, options: { showBanner = true } = {} } = args2;
   if (showBanner) {
     Ie(color2.inverse(" Mastra Init "));
   }
@@ -2058,29 +2036,46 @@ var interactivePrompt = async (args = {}) => {
         return void 0;
       },
       configureEditorWithDocsMCP: async () => {
+        const windsurfIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`windsurf`);
+        const cursorIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`cursor`);
+        const vscodeIsAlreadyInstalled = await globalMCPIsAlreadyInstalled(`vscode`);
         const editor = await ve({
           message: `Make your IDE into a Mastra expert? (Installs Mastra's MCP server)`,
           options: [
             { value: "skip", label: "Skip for now", hint: "default" },
             {
               value: "cursor",
-              label: "Cursor (project only)"
+              label: "Cursor (project only)",
+              hint: cursorIsAlreadyInstalled ? `Already installed globally` : void 0
             },
             {
               value: "cursor-global",
-              label: "Cursor (global, all projects)"
+              label: "Cursor (global, all projects)",
+              hint: cursorIsAlreadyInstalled ? `Already installed` : void 0
             },
             {
               value: "windsurf",
-              label: "Windsurf"
+              label: "Windsurf",
+              hint: windsurfIsAlreadyInstalled ? `Already installed` : void 0
             },
             {
               value: "vscode",
-              label: "VSCode"
+              label: "VSCode",
+              hint: vscodeIsAlreadyInstalled ? `Already installed` : void 0
             }
           ]
         });
         if (editor === `skip`) return void 0;
+        if (editor === `windsurf` && windsurfIsAlreadyInstalled) {
+          M.message(`
+Windsurf is already installed, skipping.`);
+          return void 0;
+        }
+        if (editor === `vscode` && vscodeIsAlreadyInstalled) {
+          M.message(`
+VSCode is already installed, skipping.`);
+          return void 0;
+        }
         if (editor === `cursor`) {
           M.message(
             `
@@ -2163,23 +2158,19 @@ function createLogger(debug = false) {
 }
 var exec2 = util.promisify(child_process.exec);
 async function cloneTemplate(options) {
-  const { template, projectName, targetDir, branch, llmProvider } = options;
-  const projectPath = targetDir ? path3.resolve(targetDir, projectName) : path3.resolve(projectName);
+  const { template, projectName, targetDir } = options;
+  const projectPath = targetDir ? path.resolve(targetDir, projectName) : path.resolve(projectName);
   const spinner4 = yoctoSpinner({ text: `Cloning template "${template.title}"...` }).start();
   try {
     if (await directoryExists(projectPath)) {
       spinner4.error(`Directory ${projectName} already exists`);
       throw new Error(`Directory ${projectName} already exists`);
     }
-    await cloneRepositoryWithoutGit(template.githubUrl, projectPath, branch);
+    await cloneRepositoryWithoutGit(template.githubUrl, projectPath);
     await updatePackageJson(projectPath, projectName);
-    const envExamplePath = path3.join(projectPath, ".env.example");
+    const envExamplePath = path.join(projectPath, ".env.example");
     if (await fileExists(envExamplePath)) {
-      const envPath = path3.join(projectPath, ".env");
-      await fs4.copyFile(envExamplePath, envPath);
-      if (llmProvider) {
-        await updateEnvFile(envPath, llmProvider);
-      }
+      await fs4.copyFile(envExamplePath, path.join(projectPath, ".env"));
     }
     spinner4.success(`Template "${template.title}" cloned successfully to ${projectName}`);
     return projectPath;
@@ -2204,27 +2195,21 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function cloneRepositoryWithoutGit(repoUrl, targetPath, branch) {
+async function cloneRepositoryWithoutGit(repoUrl, targetPath) {
   await fs4.mkdir(targetPath, { recursive: true });
   try {
     const degitRepo = repoUrl.replace("https://github.com/", "");
-    const degitRepoWithBranch = branch ? `${degitRepo}#${branch}` : degitRepo;
-    const degitCommand = shellQuote2.quote(["npx", "degit", degitRepoWithBranch, targetPath]);
+    const degitCommand = shellQuote2.quote(["npx", "degit", degitRepo, targetPath]);
     await exec2(degitCommand, {
       cwd: process.cwd()
     });
   } catch {
     try {
-      const gitArgs = ["git", "clone"];
-      if (branch) {
-        gitArgs.push("--branch", branch);
-      }
-      gitArgs.push(repoUrl, targetPath);
-      const gitCommand = shellQuote2.quote(gitArgs);
+      const gitCommand = shellQuote2.quote(["git", "clone", repoUrl, targetPath]);
       await exec2(gitCommand, {
         cwd: process.cwd()
       });
-      const gitDir = path3.join(targetPath, ".git");
+      const gitDir = path.join(targetPath, ".git");
       if (await directoryExists(gitDir)) {
         await fs4.rm(gitDir, { recursive: true, force: true });
       }
@@ -2234,7 +2219,7 @@ async function cloneRepositoryWithoutGit(repoUrl, targetPath, branch) {
   }
 }
 async function updatePackageJson(projectPath, projectName) {
-  const packageJsonPath = path3.join(projectPath, "package.json");
+  const packageJsonPath = path.join(projectPath, "package.json");
   try {
     const packageJsonContent = await fs4.readFile(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
@@ -2244,22 +2229,6 @@ async function updatePackageJson(projectPath, projectName) {
     logger.warn(`Could not update package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
-async function updateEnvFile(envPath, llmProvider) {
-  try {
-    const envContent = await fs4.readFile(envPath, "utf-8");
-    const modelString = getModelIdentifier(llmProvider);
-    if (!modelString) {
-      logger.warn(`Could not get model identifier for provider: ${llmProvider}`);
-      return;
-    }
-    const modelValue = modelString.replace(/'/g, "");
-    const updatedContent = envContent.replace(/^MODEL=.*/m, `MODEL=${modelValue}`);
-    await fs4.writeFile(envPath, updatedContent, "utf-8");
-    logger.info(`Updated MODEL in .env to ${modelValue}`);
-  } catch (error) {
-    logger.warn(`Could not update .env file: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
 async function installDependencies(projectPath, packageManager) {
   const spinner4 = yoctoSpinner({ text: "Installing dependencies..." }).start();
   try {
@@ -2344,11 +2313,9 @@ var init = async ({
   llmProvider = "openai",
   llmApiKey,
   addExample = false,
-  configureEditorWithDocsMCP,
-  versionTag
+  configureEditorWithDocsMCP
 }) => {
   s.start("Initializing Mastra");
-  const packageVersionTag = versionTag ? `@${versionTag}` : "";
   try {
     const result = await createMastraDir(directory);
     if (!result.ok) {
@@ -2376,31 +2343,26 @@ var init = async ({
       const depService = new DepsService();
       const needsLibsql = await depService.checkDependencies(["@mastra/libsql"]) !== `ok`;
       if (needsLibsql) {
-        await depService.installPackages([`@mastra/libsql${packageVersionTag}`]);
+        await depService.installPackages(["@mastra/libsql"]);
       }
       const needsMemory = components.includes(`agents`) && await depService.checkDependencies(["@mastra/memory"]) !== `ok`;
       if (needsMemory) {
-        await depService.installPackages([`@mastra/memory${packageVersionTag}`]);
+        await depService.installPackages(["@mastra/memory"]);
       }
       const needsLoggers = await depService.checkDependencies(["@mastra/loggers"]) !== `ok`;
       if (needsLoggers) {
-        await depService.installPackages([`@mastra/loggers${packageVersionTag}`]);
-      }
-      const needsObservability = await depService.checkDependencies(["@mastra/observability"]) !== `ok`;
-      if (needsObservability) {
-        await depService.installPackages([`@mastra/observability${packageVersionTag}`]);
+        await depService.installPackages(["@mastra/loggers"]);
       }
       const needsEvals = components.includes(`scorers`) && await depService.checkDependencies(["@mastra/evals"]) !== `ok`;
       if (needsEvals) {
-        await depService.installPackages([`@mastra/evals${packageVersionTag}`]);
+        await depService.installPackages(["@mastra/evals"]);
       }
     }
     const key = await getAPIKey(llmProvider || "openai");
     if (configureEditorWithDocsMCP) {
       await installMastraDocsMCPServer({
         editor: configureEditorWithDocsMCP,
-        directory: process.cwd(),
-        versionTag
+        directory: process.cwd()
       });
     }
     s.stop();
@@ -2466,7 +2428,7 @@ async function getInitCommand(pm) {
 async function initializePackageJson(pm) {
   const initCommand = await getInitCommand(pm);
   await exec3(initCommand);
-  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  const packageJsonPath = path.join(process.cwd(), "package.json");
   const packageJson = JSON.parse(await fs4.readFile(packageJsonPath, "utf-8"));
   packageJson.type = "module";
   packageJson.engines = {
@@ -2535,7 +2497,7 @@ var createMastraProject = async ({
     s2.start("Creating project");
     try {
       await fs4.mkdir(projectName);
-      projectPath = path3.resolve(originalCwd, projectName);
+      projectPath = path.resolve(originalCwd, projectName);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "EEXIST") {
         s2.stop(`A directory named "${projectName}" already exists. Please choose a different name.`);
@@ -2566,7 +2528,7 @@ var createMastraProject = async ({
     s2.start(`Installing ${pm} dependencies`);
     try {
       await exec3(`${pm} ${installCommand} zod@^4`);
-      await exec3(`${pm} ${installCommand} -D typescript @types/node`);
+      await exec3(`${pm} ${installCommand} typescript @types/node --save-dev`);
       await exec3(`echo '{
   "compilerOptions": {
     "target": "ES2022",
@@ -2642,48 +2604,39 @@ var createMastraProject = async ({
     process.exit(1);
   }
 };
-var version$1 = package_default.version;
-var create = async (args) => {
-  if (args.template !== void 0) {
-    await createFromTemplate({
-      projectName: args.projectName,
-      template: args.template,
-      timeout: args.timeout,
-      injectedAnalytics: args.analytics,
-      llmProvider: args.llmProvider
-    });
+var create = async (args2) => {
+  if (args2.template !== void 0) {
+    await createFromTemplate({ ...args2, injectedAnalytics: args2.analytics });
     return;
   }
-  const needsInteractive = args.components === void 0 || args.llmProvider === void 0 || args.addExample === void 0;
+  const needsInteractive = args2.components === void 0 || args2.llmProvider === void 0 || args2.addExample === void 0;
   const { projectName, result } = await createMastraProject({
-    projectName: args?.projectName,
-    createVersionTag: args?.createVersionTag,
-    timeout: args?.timeout,
-    llmProvider: args?.llmProvider,
-    llmApiKey: args?.llmApiKey,
+    projectName: args2?.projectName,
+    createVersionTag: args2?.createVersionTag,
+    timeout: args2?.timeout,
+    llmProvider: args2?.llmProvider,
+    llmApiKey: args2?.llmApiKey,
     needsInteractive
   });
-  const directory = args.directory || "src/";
+  const directory = args2.directory || "src/";
   if (needsInteractive && result) {
     await init({
       ...result,
       llmApiKey: result?.llmApiKey,
       components: ["agents", "tools", "workflows", "scorers"],
-      addExample: true,
-      versionTag: args.createVersionTag
+      addExample: true
     });
     postCreate({ projectName });
     return;
   }
-  const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args;
+  const { components = [], llmProvider = "openai", addExample = false, llmApiKey } = args2;
   await init({
     directory,
     components,
     llmProvider,
     addExample,
     llmApiKey,
-    configureEditorWithDocsMCP: args.mcpServer,
-    versionTag: args.createVersionTag
+    configureEditorWithDocsMCP: args2.mcpServer
   });
   postCreate({ projectName });
 };
@@ -2774,9 +2727,9 @@ async function createFromGitHubUrl(url) {
     workflows: []
   };
 }
-async function createFromTemplate(args) {
+async function createFromTemplate(args2) {
   let selectedTemplate;
-  if (args.template === true) {
+  if (args2.template === true) {
     const templates = await loadTemplates();
     const selected = await selectTemplate(templates);
     if (!selected) {
@@ -2784,11 +2737,11 @@ async function createFromTemplate(args) {
       return;
     }
     selectedTemplate = selected;
-  } else if (args.template && typeof args.template === "string") {
-    if (isGitHubUrl(args.template)) {
+  } else if (args2.template && typeof args2.template === "string") {
+    if (isGitHubUrl(args2.template)) {
       const spinner4 = Y();
       spinner4.start("Validating GitHub repository...");
-      const validation = await validateGitHubProject(args.template);
+      const validation = await validateGitHubProject(args2.template);
       if (!validation.isValid) {
         spinner4.stop("Validation failed");
         M.error("This does not appear to be a valid Mastra project:");
@@ -2796,14 +2749,14 @@ async function createFromTemplate(args) {
         throw new Error("Invalid Mastra project");
       }
       spinner4.stop("Valid Mastra project \u2713");
-      selectedTemplate = await createFromGitHubUrl(args.template);
+      selectedTemplate = await createFromGitHubUrl(args2.template);
     } else {
       const templates = await loadTemplates();
-      const found = findTemplateByName(templates, args.template);
+      const found = findTemplateByName(templates, args2.template);
       if (!found) {
-        M.error(`Template "${args.template}" not found. Available templates:`);
+        M.error(`Template "${args2.template}" not found. Available templates:`);
         templates.forEach((t) => M.info(`  - ${t.title} (use: ${t.slug.replace("template-", "")})`));
-        throw new Error(`Template "${args.template}" not found`);
+        throw new Error(`Template "${args2.template}" not found`);
       }
       selectedTemplate = found;
     }
@@ -2811,7 +2764,7 @@ async function createFromTemplate(args) {
   if (!selectedTemplate) {
     throw new Error("No template selected");
   }
-  let projectName = args.projectName;
+  let projectName = args2.projectName;
   if (!projectName) {
     const defaultName = getDefaultProjectName(selectedTemplate);
     const response = await he({
@@ -2825,41 +2778,18 @@ async function createFromTemplate(args) {
     }
     projectName = response;
   }
-  let llmProvider = args.llmProvider;
-  if (!llmProvider) {
-    const providerResponse = await ve({
-      message: "Select a default provider:",
-      options: LLM_PROVIDERS
-    });
-    if (pD(providerResponse)) {
-      M.info("Project creation cancelled.");
-      return;
-    }
-    llmProvider = providerResponse;
-  }
   let projectPath = null;
   try {
-    const analytics = args.injectedAnalytics || getAnalytics();
+    const analytics = args2.injectedAnalytics || getAnalytics();
     if (analytics) {
       analytics.trackEvent("cli_template_used", {
         template_slug: selectedTemplate.slug,
         template_title: selectedTemplate.title
       });
-      if (llmProvider) {
-        analytics.trackEvent("cli_model_provider_selected", {
-          provider: llmProvider,
-          selection_method: args.llmProvider ? "cli_args" : "interactive"
-        });
-      }
     }
-    const isBeta = version$1?.includes("beta") ?? false;
-    const isMastraTemplate = selectedTemplate.githubUrl.includes("github.com/mastra-ai/");
-    const branch = isBeta && isMastraTemplate ? "beta" : void 0;
     projectPath = await cloneTemplate({
       template: selectedTemplate,
-      projectName,
-      branch,
-      llmProvider
+      projectName
     });
     await installDependencies(projectPath);
     Me(`
@@ -2889,7 +2819,7 @@ async function createFromTemplate(args) {
 async function getPackageVersion() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
-  const pkgJsonPath = path3.join(__dirname, "..", "package.json");
+  const pkgJsonPath = path.join(__dirname, "..", "package.json");
   const content = await fsExtra$1.readJSON(pkgJsonPath);
   return content.version;
 }