@tanstack/create 0.49.1 → 0.49.2

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @tanstack/create
+
+## 0.49.2
+
+### Patch Changes
+
+- Fixed windows \\ delimiter stripping ([`7940300`](https://github.com/TanStack/cli/commit/79403004689817339ec6f6e03c20fb25e841ddb0))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/file-helpers.js

@@ -34,8 +34,10 @@ export function getBinaryFile(content) {
  */
 export function toCleanPath(absolutePath, baseDir) {
     let cleanPath = absolutePath.replace(baseDir, '');
-    if (cleanPath.startsWith('/'))
+    // Handle both Unix (/) and Windows (\) path separators
+    if (cleanPath.startsWith('/') || cleanPath.startsWith('\\')) {
         cleanPath = cleanPath.slice(1);
+    }
     return cleanPath;
 }
 export function relativePath(from, to, stripExtension = false) {

package/dist/special-steps/post-init-script.js

@@ -4,28 +4,28 @@ import { getPackageManagerScriptCommand } from '../package-manager.js';
 export async function postInitScript(environment, options) {
     const packageJsonPath = resolve(options.targetDir, 'package.json');
     if (!environment.exists(packageJsonPath)) {
-        environment.warn('Warning', 'No package.json found, skipping post-cta-init script');
+        environment.warn('Warning', 'No package.json found, skipping post-create-init script');
         return;
     }
     try {
         const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
         const packageJson = JSON.parse(packageJsonContent);
-        if (!packageJson.scripts || !packageJson.scripts['post-cta-init']) {
-            // No post-cta-init script found, skip silently
+        if (!packageJson.scripts || !packageJson.scripts['post-create-init']) {
+            // No post-create-init script found, skip silently
             return;
         }
         environment.startStep({
             id: 'post-init-script',
             type: 'command',
-            message: 'Running post-cta-init script...',
+            message: 'Running post-create-init script...',
         });
-        const { command, args } = getPackageManagerScriptCommand(options.packageManager, ['post-cta-init']);
+        const { command, args } = getPackageManagerScriptCommand(options.packageManager, ['post-create-init']);
         await environment.execute(command, args, options.targetDir, {
             inherit: true,
         });
         environment.finishStep('post-init-script', 'Post-cta-init script complete');
     }
     catch (error) {
-        environment.error(`Failed to run post-cta-init script: ${error instanceof Error ? error.message : String(error)}`);
+        environment.error(`Failed to run post-create-init script: ${error instanceof Error ? error.message : String(error)}`);
     }
 }

package/package.json

@@ -1,21 +1,13 @@
 {
   "name": "@tanstack/create",
-  "version": "0.49.1",
+  "version": "0.49.2",
   "description": "TanStack Application Builder Engine",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/types/index.d.ts",
-  "scripts": {
-    "build": "tsc && npm run copy-assets",
-    "copy-assets": "node -e \"const fs=require('fs');const path=require('path');function copyDir(src,dest){if(!fs.existsSync(dest))fs.mkdirSync(dest,{recursive:true});for(const entry of fs.readdirSync(src,{withFileTypes:true})){const srcPath=path.join(src,entry.name);const destPath=path.join(dest,entry.name);if(entry.isDirectory())copyDir(srcPath,destPath);else if(!entry.name.endsWith('.ts')||entry.name.endsWith('.d.ts'))fs.copyFileSync(srcPath,destPath)}}['react','solid'].forEach(fw=>{['add-ons','toolchains','hosts','examples','project'].forEach(dir=>{const src='src/frameworks/'+fw+'/'+dir;const dest='dist/frameworks/'+fw+'/'+dir;if(fs.existsSync(src))copyDir(src,dest)})})\"",
-    "dev": "tsc --watch",
-    "test": "eslint ./src && vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
-  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/TanStack/create-tsrouter-app.git",
+    "url": "git+https://github.com/TanStack/cli.git",
     "directory": "packages/create"
   },
   "homepage": "https://tanstack.com/router",
@@ -30,7 +22,6 @@
   ],
   "author": "Jack Herrington <jherr@pobox.com>",
   "license": "MIT",
-  "packageManager": "pnpm@9.15.5",
   "dependencies": {
     "ejs": "^3.1.10",
     "execa": "^9.5.2",
@@ -50,5 +41,13 @@
     "typescript": "^5.6.3",
     "vitest": "^3.0.8",
     "vitest-fetch-mock": "^0.4.5"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-assets",
+    "copy-assets": "node -e \"const fs=require('fs');const path=require('path');function copyDir(src,dest){if(!fs.existsSync(dest))fs.mkdirSync(dest,{recursive:true});for(const entry of fs.readdirSync(src,{withFileTypes:true})){const srcPath=path.join(src,entry.name);const destPath=path.join(dest,entry.name);if(entry.isDirectory())copyDir(srcPath,destPath);else if(!entry.name.endsWith('.ts')||entry.name.endsWith('.d.ts'))fs.copyFileSync(srcPath,destPath)}}['react','solid'].forEach(fw=>{['add-ons','toolchains','hosts','examples','project'].forEach(dir=>{const src='src/frameworks/'+fw+'/'+dir;const dest='dist/frameworks/'+fw+'/'+dir;if(fs.existsSync(src))copyDir(src,dest)})})\"",
+    "dev": "tsc --watch",
+    "test": "eslint ./src && vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   }
-}
+}

package/src/file-helpers.ts

@@ -42,7 +42,10 @@ export function getBinaryFile(content: string): string | null {
  */
 export function toCleanPath(absolutePath: string, baseDir: string): string {
   let cleanPath = absolutePath.replace(baseDir, '')
-  if (cleanPath.startsWith('/')) cleanPath = cleanPath.slice(1)
+  // Handle both Unix (/) and Windows (\) path separators
+  if (cleanPath.startsWith('/') || cleanPath.startsWith('\\')) {
+    cleanPath = cleanPath.slice(1)
+  }
   return cleanPath
 }
 

package/src/special-steps/post-init-script.ts

@@ -14,7 +14,7 @@ export async function postInitScript(
   if (!environment.exists(packageJsonPath)) {
     environment.warn(
       'Warning',
-      'No package.json found, skipping post-cta-init script',
+      'No package.json found, skipping post-create-init script',
     )
     return
   }
@@ -23,20 +23,20 @@ export async function postInitScript(
     const packageJsonContent = readFileSync(packageJsonPath, 'utf-8')
     const packageJson = JSON.parse(packageJsonContent)
 
-    if (!packageJson.scripts || !packageJson.scripts['post-cta-init']) {
-      // No post-cta-init script found, skip silently
+    if (!packageJson.scripts || !packageJson.scripts['post-create-init']) {
+      // No post-create-init script found, skip silently
       return
     }
 
     environment.startStep({
       id: 'post-init-script',
       type: 'command',
-      message: 'Running post-cta-init script...',
+      message: 'Running post-create-init script...',
     })
 
     const { command, args } = getPackageManagerScriptCommand(
       options.packageManager,
-      ['post-cta-init'],
+      ['post-create-init'],
     )
 
     await environment.execute(command, args, options.targetDir, {
@@ -46,7 +46,7 @@ export async function postInitScript(
     environment.finishStep('post-init-script', 'Post-cta-init script complete')
   } catch (error) {
     environment.error(
-      `Failed to run post-cta-init script: ${error instanceof Error ? error.message : String(error)}`,
+      `Failed to run post-create-init script: ${error instanceof Error ? error.message : String(error)}`,
     )
   }
 }

package/tests/file-helper.test.ts

@@ -6,6 +6,7 @@ import {
   isDirectory,
   readFileHelper,
   relativePath,
+  toCleanPath,
 } from '../src/file-helpers.js'
 
 vi.mock('node:fs', () => fs)
@@ -15,6 +16,24 @@ beforeEach(() => {
   vol.reset()
 })
 
+describe('toCleanPath', () => {
+  it('should strip Unix-style leading slash', () => {
+    expect(toCleanPath('/projects/my-app/src/file.ts', '/projects/my-app')).toBe(
+      'src/file.ts',
+    )
+  })
+
+  it('should strip Windows-style leading backslash', () => {
+    expect(
+      toCleanPath('C:\\Projects\\my-app\\src\\file.ts', 'C:\\Projects\\my-app'),
+    ).toBe('src\\file.ts')
+  })
+
+  it('should handle paths without leading separator', () => {
+    expect(toCleanPath('/projects/my-app', '/projects/my-app')).toBe('')
+  })
+})
+
 describe('relativePath', () => {
   it('relative path with the same directory and strip extension', () => {
     expect(relativePath('src/utils.ts', 'src/index.ts', true)).toBe('./index')

package/tests/special-steps.test.ts

@@ -34,10 +34,10 @@ describe('Special Steps', () => {
   })
 
   describe('postInitScript', () => {
-    it('should run post-cta-init script when it exists', async () => {
+    it('should run post-create-init script when it exists', async () => {
       const mockPackageJson = {
         scripts: {
-          'post-cta-init': 'echo "Running post-cta-init"',
+          'post-create-init': 'echo "Running post-create-init"',
         },
       }
 
@@ -51,12 +51,12 @@ describe('Special Steps', () => {
       expect(mockEnvironment.startStep).toHaveBeenCalledWith({
         id: 'post-init-script',
         type: 'command',
-        message: 'Running post-cta-init script...',
+        message: 'Running post-create-init script...',
       })
 
       expect(mockEnvironment.execute).toHaveBeenCalledWith(
         'npm',
-        ['run', 'post-cta-init'],
+        ['run', 'post-create-init'],
         '/test/project',
         { inherit: true },
       )
@@ -74,12 +74,12 @@ describe('Special Steps', () => {
 
       expect(mockEnvironment.warn).toHaveBeenCalledWith(
         'Warning',
-        'No package.json found, skipping post-cta-init script',
+        'No package.json found, skipping post-create-init script',
       )
       expect(mockEnvironment.execute).not.toHaveBeenCalled()
     })
 
-    it('should skip when post-cta-init script does not exist', async () => {
+    it('should skip when post-create-init script does not exist', async () => {
       const mockPackageJson = {
         scripts: {
           build: 'echo "Building"',
@@ -100,10 +100,10 @@ describe('Special Steps', () => {
     it('should handle different package managers', async () => {
       const packageManagers = ['yarn', 'pnpm', 'bun', 'deno'] as const
       const expectedCommands = {
-        yarn: { command: 'yarn', args: ['run', 'post-cta-init'] },
-        pnpm: { command: 'pnpm', args: ['post-cta-init'] },
-        bun: { command: 'bun', args: ['--bun', 'run', 'post-cta-init'] },
-        deno: { command: 'deno', args: ['task', 'post-cta-init'] },
+        yarn: { command: 'yarn', args: ['run', 'post-create-init'] },
+        pnpm: { command: 'pnpm', args: ['post-create-init'] },
+        bun: { command: 'bun', args: ['--bun', 'run', 'post-create-init'] },
+        deno: { command: 'deno', args: ['task', 'post-create-init'] },
       }
 
       for (const pm of packageManagers) {
@@ -111,7 +111,7 @@ describe('Special Steps', () => {
         vi.clearAllMocks()
         vi.spyOn(mockEnvironment, 'exists').mockReturnValue(true)
         vi.mocked(fs.readFileSync).mockReturnValue(
-          JSON.stringify({ scripts: { 'post-cta-init': 'test' } }),
+          JSON.stringify({ scripts: { 'post-create-init': 'test' } }),
         )
 
         await postInitScript(mockEnvironment, mockOptions)
@@ -133,7 +133,7 @@ describe('Special Steps', () => {
 
       vi.spyOn(mockEnvironment, 'exists').mockReturnValue(true)
       vi.mocked(fs.readFileSync).mockReturnValue(
-        JSON.stringify({ scripts: { 'post-cta-init': 'test' } }),
+        JSON.stringify({ scripts: { 'post-create-init': 'test' } }),
       )
 
       await runSpecialSteps(mockEnvironment, mockOptions, specialSteps)

package/dist/frameworks/react/add-ons/ai/assets/src/data/demo-guitars.js

@@ -1,67 +0,0 @@
-const guitars = [
-    {
-        id: 1,
-        name: 'TanStack Ukelele',
-        image: '/example-ukelele-tanstack.jpg',
-        description: "Introducing the TanStack Signature Ukulele—a beautifully handcrafted concert ukulele that combines exceptional sound quality with distinctive style. Featuring a warm, resonant koa-wood body with natural grain patterns, this instrument delivers the rich, mellow tones Hawaii is famous for. The exclusive TanStack palm tree inlay on the soundhole adds a unique touch of island flair, while the matching branded headstock makes this a true collector's piece for developers and musicians alike. Whether you're a beginner looking for a quality starter instrument or an experienced player wanting something special, the TanStack Ukulele brings together craftsmanship, character, and that unmistakable tropical spirit.",
-        shortDescription: 'Premium koa-wood ukulele featuring exclusive TanStack branding, perfect for beach vibes and island-inspired melodies.',
-        price: 299,
-    },
-    {
-        id: 2,
-        name: 'Video Game Guitar',
-        image: '/example-guitar-video-games.jpg',
-        description: "The Video Game Guitar is a unique acoustic guitar that features a design inspired by video games. It has a sleek, high-gloss finish and a comfortable playability. The guitar's ergonomic body and fast neck profile ensure comfortable playability for hours on end.",
-        shortDescription: 'A unique electric guitar with a video game design, high-gloss finish, and comfortable playability.',
-        price: 699,
-    },
-    {
-        id: 3,
-        name: 'Superhero Guitar',
-        image: '/example-guitar-superhero.jpg',
-        description: "The Superhero Guitar is a bold black electric guitar that stands out with its unique superhero logo design. Its sleek, high-gloss finish and powerful pickups make it perfect for high-energy performances. The guitar's ergonomic body and fast neck profile ensure comfortable playability for hours on end.",
-        shortDescription: 'A bold black electric guitar with a unique superhero logo, high-gloss finish, and powerful pickups.',
-        price: 699,
-    },
-    {
-        id: 4,
-        name: 'Motherboard Guitar',
-        image: '/example-guitar-motherboard.jpg',
-        description: "This guitar is a tribute to the motherboard of a computer. It's a unique and stylish instrument that will make you feel like a hacker. The intricate circuit-inspired design features actual LED lights that pulse with your playing intensity, while the neck is inlaid with binary code patterns that glow under stage lights. Each pickup has been custom-wound to produce tones ranging from clean digital precision to glitched-out distortion, perfect for electronic music fusion. The Motherboard Guitar seamlessly bridges the gap between traditional craftsmanship and cutting-edge technology, making it the ultimate instrument for the digital age musician.",
-        shortDescription: 'A tech-inspired electric guitar featuring LED lights and binary code inlays that glow under stage lights.',
-        price: 649,
-    },
-    {
-        id: 5,
-        name: 'Racing Guitar',
-        image: '/example-guitar-racing.jpg',
-        description: "Engineered for speed and precision, the Racing Guitar embodies the spirit of motorsport in every curve and contour. Its aerodynamic body, painted in classic racing stripes and high-gloss finish, is crafted from lightweight materials that allow for effortless play during extended performances. The custom low-action setup and streamlined neck profile enable lightning-fast fretwork, while specially designed pickups deliver a high-octane tone that cuts through any mix. Built with performance-grade hardware including racing-inspired control knobs and checkered flag inlays, this guitar isn't just played—it's driven to the limits of musical possibility.",
-        shortDescription: 'A lightweight, aerodynamic guitar with racing stripes and a low-action setup designed for speed and precision.',
-        price: 679,
-    },
-    {
-        id: 6,
-        name: 'Steamer Trunk Guitar',
-        image: '/example-guitar-steamer-trunk.jpg',
-        description: 'The Steamer Trunk Guitar is a semi-hollow body instrument that exudes vintage charm and character. Crafted from reclaimed antique luggage wood, it features brass hardware that adds a touch of elegance and durability. The fretboard is adorned with a world map inlay, making it a unique piece that tells a story of travel and adventure.',
-        shortDescription: 'A semi-hollow body guitar with brass hardware and a world map inlay, crafted from reclaimed antique luggage wood.',
-        price: 629,
-    },
-    {
-        id: 7,
-        name: "Travelin' Man Guitar",
-        image: '/example-guitar-traveling.jpg',
-        description: "The Travelin' Man Guitar is an acoustic masterpiece adorned with vintage postcards from around the world. Each postcard tells a story of adventure and wanderlust, making this guitar a unique piece of art. Its rich, resonant tones and comfortable playability make it perfect for musicians who love to travel and perform.",
-        shortDescription: 'An acoustic guitar with vintage postcards, rich tones, and comfortable playability.',
-        price: 499,
-    },
-    {
-        id: 8,
-        name: 'Flowerly Love Guitar',
-        image: '/example-guitar-flowers.jpg',
-        description: "The Flowerly Love Guitar is an acoustic masterpiece adorned with intricate floral designs on its body. Each flower is hand-painted, adding a touch of nature's beauty to the instrument. Its warm, resonant tones make it perfect for both intimate performances and larger gatherings.",
-        shortDescription: 'An acoustic guitar with hand-painted floral designs and warm, resonant tones.',
-        price: 599,
-    },
-];
-export default guitars;

package/dist/frameworks/react/add-ons/ai/assets/src/hooks/demo-useAudioRecorder.js

@@ -1,70 +0,0 @@
-import { useCallback, useRef, useState } from 'react';
-/**
- * Hook for recording audio and transcribing it via the transcription API.
- */
-export function useAudioRecorder() {
-    const [isRecording, setIsRecording] = useState(false);
-    const [isTranscribing, setIsTranscribing] = useState(false);
-    const mediaRecorderRef = useRef(null);
-    const chunksRef = useRef([]);
-    const startRecording = useCallback(async () => {
-        try {
-            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-            const mediaRecorder = new MediaRecorder(stream, {
-                mimeType: 'audio/webm;codecs=opus',
-            });
-            mediaRecorderRef.current = mediaRecorder;
-            chunksRef.current = [];
-            mediaRecorder.ondataavailable = (e) => {
-                if (e.data.size > 0) {
-                    chunksRef.current.push(e.data);
-                }
-            };
-            mediaRecorder.start();
-            setIsRecording(true);
-        }
-        catch (error) {
-            console.error('Failed to start recording:', error);
-            alert('Could not access microphone. Please check permissions.');
-        }
-    }, []);
-    const stopRecording = useCallback(async () => {
-        return new Promise((resolve) => {
-            const mediaRecorder = mediaRecorderRef.current;
-            if (!mediaRecorder) {
-                resolve(null);
-                return;
-            }
-            mediaRecorder.onstop = async () => {
-                setIsRecording(false);
-                setIsTranscribing(true);
-                const audioBlob = new Blob(chunksRef.current, { type: 'audio/webm' });
-                // Stop all tracks
-                mediaRecorder.stream.getTracks().forEach((track) => track.stop());
-                try {
-                    const formData = new FormData();
-                    formData.append('audio', new File([audioBlob], 'recording.webm', { type: 'audio/webm' }));
-                    formData.append('model', 'whisper-1');
-                    const response = await fetch('/demo/api/transcription', {
-                        method: 'POST',
-                        body: formData,
-                    });
-                    if (!response.ok) {
-                        const errorData = await response.json();
-                        throw new Error(errorData.error || 'Transcription failed');
-                    }
-                    const result = await response.json();
-                    setIsTranscribing(false);
-                    resolve(result.text || null);
-                }
-                catch (error) {
-                    console.error('Transcription error:', error);
-                    setIsTranscribing(false);
-                    resolve(null);
-                }
-            };
-            mediaRecorder.stop();
-        });
-    }, []);
-    return { isRecording, isTranscribing, startRecording, stopRecording };
-}

package/dist/frameworks/react/add-ons/ai/assets/src/hooks/demo-useTTS.js

@@ -1,66 +0,0 @@
-import { useCallback, useRef, useState } from 'react';
-/**
- * Hook for text-to-speech playback via the TTS API.
- */
-export function useTTS() {
-    const [playingId, setPlayingId] = useState(null);
-    const audioRef = useRef(null);
-    const speak = useCallback(async (text, id) => {
-        // Stop any currently playing audio
-        if (audioRef.current) {
-            audioRef.current.pause();
-            audioRef.current = null;
-        }
-        setPlayingId(id);
-        try {
-            const response = await fetch('/demo/api/tts', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    text,
-                    voice: 'nova',
-                    model: 'tts-1',
-                    format: 'mp3',
-                }),
-            });
-            if (!response.ok) {
-                const errorData = await response.json();
-                throw new Error(errorData.error || 'TTS failed');
-            }
-            const result = await response.json();
-            // Convert base64 to audio and play
-            const audioData = atob(result.audio);
-            const bytes = new Uint8Array(audioData.length);
-            for (let i = 0; i < audioData.length; i++) {
-                bytes[i] = audioData.charCodeAt(i);
-            }
-            const blob = new Blob([bytes], { type: result.contentType });
-            const url = URL.createObjectURL(blob);
-            const audio = new Audio(url);
-            audioRef.current = audio;
-            audio.onended = () => {
-                URL.revokeObjectURL(url);
-                setPlayingId(null);
-                audioRef.current = null;
-            };
-            audio.onerror = () => {
-                URL.revokeObjectURL(url);
-                setPlayingId(null);
-                audioRef.current = null;
-            };
-            await audio.play();
-        }
-        catch (error) {
-            console.error('TTS error:', error);
-            setPlayingId(null);
-        }
-    }, []);
-    const stop = useCallback(() => {
-        if (audioRef.current) {
-            audioRef.current.pause();
-            audioRef.current = null;
-        }
-        setPlayingId(null);
-    }, []);
-    return { playingId, speak, stop };
-}

package/dist/frameworks/react/add-ons/ai/assets/src/lib/demo-ai-hook.js

@@ -1,11 +0,0 @@
-import { fetchServerSentEvents, useChat, createChatClientOptions, } from '@tanstack/ai-react';
-import { clientTools } from '@tanstack/ai-client';
-import { recommendGuitarToolDef } from '@/lib/demo-guitar-tools';
-const recommendGuitarToolClient = recommendGuitarToolDef.client(({ id }) => ({
-    id: +id,
-}));
-const chatOptions = createChatClientOptions({
-    connection: fetchServerSentEvents('/demo/api/ai/chat'),
-    tools: clientTools(recommendGuitarToolClient),
-});
-export const useGuitarRecommendationChat = () => useChat(chatOptions);

package/dist/frameworks/react/add-ons/ai/assets/src/lib/demo-guitar-tools.js

@@ -1,32 +0,0 @@
-import { toolDefinition } from '@tanstack/ai';
-import { z } from 'zod';
-import guitars from '@/data/demo-guitars';
-// Tool definition for getting guitars
-export const getGuitarsToolDef = toolDefinition({
-    name: 'getGuitars',
-    description: 'Get all products from the database',
-    inputSchema: z.object({}),
-    outputSchema: z.array(z.object({
-        id: z.number(),
-        name: z.string(),
-        image: z.string(),
-        description: z.string(),
-        shortDescription: z.string(),
-        price: z.number(),
-    })),
-});
-// Server implementation
-export const getGuitars = getGuitarsToolDef.server(() => guitars);
-// Tool definition for guitar recommendation
-export const recommendGuitarToolDef = toolDefinition({
-    name: 'recommendGuitar',
-    description: 'REQUIRED tool to display a guitar recommendation to the user. This tool MUST be used whenever recommending a guitar - do NOT write recommendations yourself. This displays the guitar in a special appealing format with a buy button.',
-    inputSchema: z.object({
-        id: z
-            .union([z.string(), z.number()])
-            .describe('The ID of the guitar to recommend (from the getGuitars results)'),
-    }),
-    outputSchema: z.object({
-        id: z.number(),
-    }),
-});

package/dist/frameworks/react/add-ons/ai/assets/src/routes/demo/api.ai.chat.js

@@ -1,87 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router';
-import { chat, maxIterations, toServerSentEventsResponse } from '@tanstack/ai';
-import { anthropicText } from '@tanstack/ai-anthropic';
-import { openaiText } from '@tanstack/ai-openai';
-import { geminiText } from '@tanstack/ai-gemini';
-import { ollamaText } from '@tanstack/ai-ollama';
-import { getGuitars, recommendGuitarToolDef } from '@/lib/demo-guitar-tools';
-const SYSTEM_PROMPT = `You are a helpful assistant for a store that sells guitars.
-
-CRITICAL INSTRUCTIONS - YOU MUST FOLLOW THIS EXACT WORKFLOW:
-
-When a user asks for a guitar recommendation:
-1. FIRST: Use the getGuitars tool (no parameters needed)
-2. SECOND: Use the recommendGuitar tool with the ID of the guitar you want to recommend
-3. NEVER write a recommendation directly - ALWAYS use the recommendGuitar tool
-
-IMPORTANT:
-- The recommendGuitar tool will display the guitar in a special, appealing format
-- You MUST use recommendGuitar for ANY guitar recommendation
-- ONLY recommend guitars from our inventory (use getGuitars first)
-- The recommendGuitar tool has a buy button - this is how customers purchase
-- Do NOT describe the guitar yourself - let the recommendGuitar tool do it
-`;
-export const Route = createFileRoute('/demo/api/ai/chat')({
-    server: {
-        handlers: {
-            POST: async ({ request }) => {
-                // Capture request signal before reading body (it may be aborted after body is consumed)
-                const requestSignal = request.signal;
-                // If request is already aborted, return early
-                if (requestSignal.aborted) {
-                    return new Response(null, { status: 499 }); // 499 = Client Closed Request
-                }
-                const abortController = new AbortController();
-                try {
-                    const body = await request.json();
-                    const { messages } = body;
-                    // Determine the best available provider
-                    let provider = 'ollama';
-                    let model = 'mistral:7b';
-                    if (process.env.ANTHROPIC_API_KEY) {
-                        provider = 'anthropic';
-                        model = 'claude-haiku-4-5';
-                    }
-                    else if (process.env.OPENAI_API_KEY) {
-                        provider = 'openai';
-                        model = 'gpt-4o';
-                    }
-                    else if (process.env.GEMINI_API_KEY) {
-                        provider = 'gemini';
-                        model = 'gemini-2.0-flash-exp';
-                    }
-                    // Adapter factory pattern for multi-vendor support
-                    const adapterConfig = {
-                        anthropic: () => anthropicText((model || 'claude-haiku-4-5')),
-                        openai: () => openaiText((model || 'gpt-4o')),
-                        gemini: () => geminiText((model || 'gemini-2.0-flash-exp')),
-                        ollama: () => ollamaText((model || 'mistral:7b')),
-                    };
-                    const adapter = adapterConfig[provider]();
-                    const stream = chat({
-                        adapter,
-                        tools: [
-                            getGuitars, // Server tool
-                            recommendGuitarToolDef, // No server execute - client will handle
-                        ],
-                        systemPrompts: [SYSTEM_PROMPT],
-                        agentLoopStrategy: maxIterations(5),
-                        messages,
-                        abortController,
-                    });
-                    return toServerSentEventsResponse(stream, { abortController });
-                }
-                catch (error) {
-                    // If request was aborted, return early (don't send error response)
-                    if (error.name === 'AbortError' || abortController.signal.aborted) {
-                        return new Response(null, { status: 499 }); // 499 = Client Closed Request
-                    }
-                    return new Response(JSON.stringify({ error: 'Failed to process chat request' }), {
-                        status: 500,
-                        headers: { 'Content-Type': 'application/json' },
-                    });
-                }
-            },
-        },
-    },
-});