create-auto-app 0.2.3 → 0.3.0

package/templates/shopping-app/auto.config.ts

@@ -1,12 +1,34 @@
 import { on, dispatch, fold } from '@auto-engineer/cli';
 import type { Command, Event } from '@auto-engineer/message-bus';
 import { type ExportSchemaCommand, type SchemaExportedEvent, type SchemaExportFailedEvent } from '@auto-engineer/flow';
-import { type GenerateServerCommand, type ServerGeneratedEvent, type ServerGenerationFailedEvent } from '@auto-engineer/server-generator-apollo-emmett';
-import { type ImplementServerCommand, type ServerImplementedEvent, type ServerImplementationFailedEvent } from '@auto-engineer/server-implementer';
-import { type CheckTypesCommand, type TypeCheckPassedEvent, type TypeCheckFailedEvent, CheckTestsCommand, CheckLintCommand } from '@auto-engineer/server-checks';
+import {
+  type GenerateServerCommand,
+  type ServerGeneratedEvent,
+  type ServerGenerationFailedEvent,
+} from '@auto-engineer/server-generator-apollo-emmett';
+import {
+  type ImplementServerCommand,
+  type ServerImplementedEvent,
+  type ServerImplementationFailedEvent,
+} from '@auto-engineer/server-implementer';
+import {
+  type CheckTypesCommand,
+  type TypeCheckPassedEvent,
+  type TypeCheckFailedEvent,
+  CheckTestsCommand,
+  CheckLintCommand,
+} from '@auto-engineer/server-checks';
 import { CheckClientCommand } from '@auto-engineer/frontend-checks';
-import { type GenerateIACommand, type IAGeneratedEvent, type IAGenerationFailedEvent } from '@auto-engineer/information-architect';
-import { type ImplementClientCommand, type ClientImplementedEvent, type ClientImplementationFailedEvent } from '@auto-engineer/frontend-implementer';
+import {
+  type GenerateIACommand,
+  type IAGeneratedEvent,
+  type IAGenerationFailedEvent,
+} from '@auto-engineer/information-architect';
+import {
+  type ImplementClientCommand,
+  type ClientImplementedEvent,
+  type ClientImplementationFailedEvent,
+} from '@auto-engineer/frontend-implementer';
 
 // Plugin configuration
 export default {
@@ -52,57 +74,68 @@ const pipelineStatus = fold<string, Event>(
       default:
         return state;
     }
-  }
+  },
 );
 
 // State: Track last error
-const lastError = fold<any, Event>(
-  '*',
-  (state = null, event) => {
-    if (event.type.endsWith('Failed') || event.type.endsWith('Error')) {
-      return {
-        type: event.type,
-        data: event.data,
-        timestamp: new Date().toISOString(),
-      };
-    }
-    return state;
+const lastError = fold<any, Event>('*', (state = null, event) => {
+  if (event.type.endsWith('Failed') || event.type.endsWith('Error')) {
+    return {
+      type: event.type,
+      data: event.data,
+      timestamp: new Date().toISOString(),
+    };
   }
-);
+  return state;
+});
 
 // State: Track completed operations
-const completedOperations = fold<string[], Event>(
-  '*',
-  (state = [], event) => {
-    if (event.type.endsWith('Passed') || event.type.endsWith('Generated') || event.type.endsWith('Implemented')) {
-      return [...state, event.type];
-    }
-    return state;
+const completedOperations = fold<string[], Event>('*', (state = [], event) => {
+  if (event.type.endsWith('Passed') || event.type.endsWith('Generated') || event.type.endsWith('Implemented')) {
+    return [...state, event.type];
   }
-);
+  return state;
+});
 
-on<SchemaExportedEvent>('SchemaExported', (event) => dispatch<GenerateServerCommand>(
-  { type: 'GenerateServer', data: { schemaPath: event.data.outputPath, destination: event.data.outputPath.replace('/schema.json', '/server') } }
-));
+on<SchemaExportedEvent>('SchemaExported', (event) =>
+  dispatch<GenerateServerCommand>({
+    type: 'GenerateServer',
+    data: { schemaPath: event.data.outputPath, destination: event.data.outputPath.replace('/schema.json', '/server') },
+  }),
+);
 
-on<ServerGeneratedEvent>('ServerGenerated', (event) => dispatch.parallel<ImplementServerCommand | GenerateIACommand>([
-  { type: 'ImplementServer', data: { serverDirectory: event.data.serverDir } },
-  { type: 'GenerateIA', data: { outputDir: event.data.destination + '/.context', flowFiles: [event.data.schemaPath] } },
-]));
+on<ServerGeneratedEvent>('ServerGenerated', (event) =>
+  dispatch.parallel<ImplementServerCommand | GenerateIACommand>([
+    { type: 'ImplementServer', data: { serverDirectory: event.data.serverDir } },
+    {
+      type: 'GenerateIA',
+      data: { outputDir: event.data.destination + '/.context', flowFiles: [event.data.schemaPath] },
+    },
+  ]),
+);
 
-on<ServerImplementedEvent>('ServerImplemented', (event) => dispatch.parallel<CheckTypesCommand | CheckTestsCommand | CheckLintCommand>([
-  { type: 'CheckTypes', data: { targetDirectory: event.data.serverDirectory, scope: 'project' } },
-  { type: 'CheckTests', data: { targetDirectory: event.data.serverDirectory, scope: 'project' } },
-  { type: 'CheckLint', data: { targetDirectory: event.data.serverDirectory, scope: 'project' } }
-]));
+on<ServerImplementedEvent>('ServerImplemented', (event) =>
+  dispatch.parallel<CheckTypesCommand | CheckTestsCommand | CheckLintCommand>([
+    { type: 'CheckTypes', data: { targetDirectory: event.data.serverDirectory, scope: 'project' } },
+    { type: 'CheckTests', data: { targetDirectory: event.data.serverDirectory, scope: 'project' } },
+    { type: 'CheckLint', data: { targetDirectory: event.data.serverDirectory, scope: 'project' } },
+  ]),
+);
 
-on<IAGeneratedEvent>('IAGenerated', (event) => dispatch<ImplementClientCommand>(
-  { type: 'ImplementClient', data: { projectDir: event.data.outputDir.replace('/.context', '/client'), iaSchemeDir: event.data.outputDir, designSystemPath: './.context/design-system.md' } }
-));
+on<IAGeneratedEvent>('IAGenerated', (event) =>
+  dispatch<ImplementClientCommand>({
+    type: 'ImplementClient',
+    data: {
+      projectDir: event.data.outputDir.replace('/.context', '/client'),
+      iaSchemeDir: event.data.outputDir,
+      designSystemPath: './.context/design-system.md',
+    },
+  }),
+);
 
-on<ClientImplementedEvent>('ClientImplemented', (event) => dispatch<CheckClientCommand>(
-  { type: 'CheckClient', data: { clientDirectory: './client', skipBrowserChecks: true } }
-));
+on<ClientImplementedEvent>('ClientImplemented', (event) =>
+  dispatch<CheckClientCommand>({ type: 'CheckClient', data: { clientDirectory: './client', skipBrowserChecks: true } }),
+);
 
 // on<ClientImplementationFailedEvent>('ClientImplementationFailed', (event) =>
 //   dispatch<ImplementClientCommand>({
@@ -143,4 +176,4 @@ on<ClientImplementedEvent>('ClientImplemented', (event) => dispatch<CheckClientC
 // // Reset retry count on success
 // on<TypeCheckPassedEvent>('TypeCheckPassed', () => {
 //   retryCount = 0;
-// });
+// });

package/templates/shopping-app/client/src/App.tsx

@@ -3,18 +3,18 @@ import { BrowserRouter, Route, Routes } from 'react-router-dom';
 import { apolloClient } from '@/apolloClient';
 import { Index } from '@/pages/Index';
 import { NotFound } from '@/pages/NotFound';
-    import { AssistantChatPage } from '@/pages/AssistantChatPage';
-    import { SuggestedItemsPage } from '@/pages/SuggestedItemsPage';
+import { AssistantChatPage } from '@/pages/AssistantChatPage';
+import { SuggestedItemsPage } from '@/pages/SuggestedItemsPage';
 
 export const App = () => (
-    <ApolloProvider client={apolloClient}>
-        <BrowserRouter>
-            <Routes>
-                <Route path="/" element={<Index />} />
-                                    <Route path="/" element={<AssistantChatPage />} />
-                                    <Route path="/suggested-items/:sessionId" element={<SuggestedItemsPage />} />
-                                <Route path="*" element={<NotFound />} />
-            </Routes>
-        </BrowserRouter>
-    </ApolloProvider>
-);
+  <ApolloProvider client={apolloClient}>
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<Index />} />
+        <Route path="/" element={<AssistantChatPage />} />
+        <Route path="/suggested-items/:sessionId" element={<SuggestedItemsPage />} />
+        <Route path="*" element={<NotFound />} />
+      </Routes>
+    </BrowserRouter>
+  </ApolloProvider>
+);

package/templates/shopping-app/client/src/components/molecules/QuantitySelector.tsx

@@ -1,8 +1,8 @@
-import { <TextField> } from "@/components/atoms/<textfield>";
-import { !!<IconButton> } from "@/components/atoms/!!<iconbutton>";
+import { TextField } from '@/components/atoms/textfield';
+import { IconButton } from '@/components/atoms/iconbutton';
 
 // Component for adjusting item quantities
 
 export function QuantitySelector() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/client/src/components/molecules/ShoppingCriteriaForm.tsx

@@ -1,8 +1,8 @@
-import { <TextField> | Multiline } from "@/components/atoms/<textfield> | multiline";
-import { <Button> } from "@/components/atoms/<button>";
+import { TextField } from '@/components/atoms/textfield';
+import { Button } from '@/components/atoms/button';
 
 // Form for entering shopping criteria with examples and submission
 
 export function ShoppingCriteriaForm() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/client/src/components/molecules/SuggestedItemCard.tsx

@@ -1,10 +1,10 @@
-import { <Card> } from "@/components/atoms/<card>";
-import { <CardHeader> } from "@/components/atoms/<cardheader>";
-import { <TextField> } from "@/components/atoms/<textfield>";
-import { <Button> } from "@/components/atoms/<button>";
+import { Card } from '@/components/atoms/card';
+import { CardHeader } from '@/components/atoms/cardheader';
+import { TextField } from '@/components/atoms/textfield';
+import { Button } from '@/components/atoms/button';
 
 // Card displaying a suggested item with quantity selector and reason
 
 export function SuggestedItemCard() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/client/src/components/organisms/AssistantChatInterface.tsx

@@ -1,4 +1,4 @@
-import { ShoppingCriteriaForm } from "@/components/molecules/ShoppingCriteriaForm";
+import { ShoppingCriteriaForm } from '@/components/molecules/ShoppingCriteriaForm';
 
 // Main interface for entering shopping criteria and starting a session
 // Specs:
@@ -10,5 +10,5 @@ import { ShoppingCriteriaForm } from "@/components/molecules/ShoppingCriteriaFor
 // - show the header on top of the page
 
 export function AssistantChatInterface() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/client/src/components/organisms/PageHeader.tsx

@@ -1,6 +1,5 @@
-
 // Header component shown on top of pages
 
 export function PageHeader() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/client/src/components/organisms/SuggestedItemsList.tsx

@@ -1,4 +1,4 @@
-import { SuggestedItemCard } from "@/components/molecules/SuggestedItemCard";
+import { SuggestedItemCard } from '@/components/molecules/SuggestedItemCard';
 
 // Display suggested items with selection and cart functionality
 // Specs:
@@ -11,5 +11,5 @@ import { SuggestedItemCard } from "@/components/molecules/SuggestedItemCard";
 // - provide feedback when items are added
 
 export function SuggestedItemsList() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/client/src/index.css

@@ -3,8 +3,7 @@
 @tailwind utilities;
 
 @layer base {
-:root {
-
+  :root {
     --radius: 0.5rem;
 
     --background: 0 0% 100%;
@@ -70,11 +69,9 @@
     --sidebar-border: 240 6% 90%;
 
     --sidebar-ring: 240 6% 10%;
+  }
 
-}
-
-.dark {
-
+  .dark {
     --background: 240 6% 10%;
 
     --foreground: 0 0% 98%;
@@ -138,16 +135,15 @@
     --sidebar-border: 240 5% 34%;
 
     --sidebar-ring: 240 5% 84%;
-
-}
+  }
 }
 
 @layer base {
-* {
-@apply border-border;
-}
+  * {
+    @apply border-border;
+  }
 
-body {
-@apply bg-background text-foreground;
-}
+  body {
+    @apply bg-background text-foreground;
+  }
 }

package/templates/shopping-app/client/src/pages/AssistantChatPage.tsx

@@ -1,8 +1,8 @@
-import { PageHeader } from "@/components/organisms/PageHeader";
-import { AssistantChatInterface } from "@/components/organisms/AssistantChatInterface";
+import { PageHeader } from '@/components/organisms/PageHeader';
+import { AssistantChatInterface } from '@/components/organisms/AssistantChatInterface';
 
 // Main page where users enter shopping criteria
 
 export function AssistantChatPage() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/client/src/pages/SuggestedItemsPage.tsx

@@ -1,8 +1,8 @@
-import { PageHeader } from "@/components/organisms/PageHeader";
-import { SuggestedItemsList } from "@/components/organisms/SuggestedItemsList";
+import { PageHeader } from '@/components/organisms/PageHeader';
+import { SuggestedItemsList } from '@/components/organisms/SuggestedItemsList';
 
 // Page displaying AI-suggested items for the shopping criteria
 
 export function SuggestedItemsPage() {
-    return <div />;
-}
+  return <div />;
+}

package/templates/shopping-app/example-integrations/product-catalogue/src/product-catalogue-integration.ts

@@ -38,7 +38,7 @@ type ProductCatalogQueries = {
   ProductDetails: (params: { id: string }) => Promise<ProductDetails>;
 };
 
-export const ProductCatalog: Integration<'product-catalog', ProductCatalogQueries> = {
+const _ProductCatalog: Integration<'product-catalog', ProductCatalogQueries> = {
   __brand: 'Integration' as const,
   type: 'product-catalog' as const,
   name: 'product-catalog',
@@ -47,9 +47,7 @@ export const ProductCatalog: Integration<'product-catalog', ProductCatalogQuerie
     // GET /api/products
     Products: async (): Promise<Products> => {
       try {
-        const res = await productClient.get<GetApiProductsResponses, unknown, false>({
-          url: '/api/products',
-        });
+        const res = await productClient.get<GetApiProductsResponses, unknown, false>({ url: '/api/products' });
         if (res.error !== undefined) console.error('Failed to fetch products:', res.error);
         return { type: 'Products', data: { products: (res.data as Product[]) ?? [] } };
       } catch (err) {
@@ -96,9 +94,7 @@ export const ProductCatalog: Integration<'product-catalog', ProductCatalogQuerie
           path: { id },
         });
         if (res.response.status === 404 || res.error !== undefined) {
-          if (res.response.status !== 404) {
-            console.error(`Error fetching product "${id}":`, res.error);
-          }
+          if (res.response.status !== 404) console.error(`Error fetching product "${id}":`, res.error);
           return { type: 'ProductDetails', data: { product: null } };
         }
         return { type: 'ProductDetails', data: { product: res.data ?? null } };
@@ -110,116 +106,127 @@ export const ProductCatalog: Integration<'product-catalog', ProductCatalogQuerie
   },
 };
 
-// ---------- MCP tools  ----------
-
-// All products
-registerTool<Record<string, unknown>>(
-  'PRODUCT_CATALOGUE_PRODUCTS',
-  {
-    title: 'Get All Products',
-    description: 'Fetches all products from the product catalog',
-    inputSchema: {},
-    schema: zGetApiProductsResponse,
-    schemaName: 'GetApiProductsResponse',
-    schemaDescription: 'Array of ProductCatalogItem',
-  },
-  async () => {
-    const queries = ProductCatalog.Queries as ProductCatalogQueries;
-    if (queries?.Products == null) {
-      return {
-        content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.Products is not available' }],
-        isError: true,
-      };
-    }
-    const productsQuery = queries.Products;
-    const result = await productsQuery();
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
-  },
-);
+// ---------- Lazy MCP tool registration  ----------
+let _toolsRegistered = false;
 
-// By category
-interface ProductsByCategoryParams extends Record<string, unknown> {
-  category: string;
-}
-registerTool<ProductsByCategoryParams>(
-  'PRODUCT_CATALOGUE_PRODUCTS_BY_CATEGORY',
-  {
-    title: 'Get Products by Category',
-    description: 'Fetches products from a specific category',
-    inputSchema: { category: z.string().min(1, 'Category is required') },
-    schema: zGetApiProductsCategoryByCategoryResponse,
-    schemaName: 'GetApiProductsCategoryByCategoryResponse',
-    schemaDescription: 'Array of ProductCatalogItem',
-  },
-  async ({ category }) => {
-    const queries = ProductCatalog.Queries as ProductCatalogQueries;
-    if (queries?.ProductsByCategory == null) {
-      return {
-        content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductsByCategory is not available' }],
-        isError: true,
-      };
-    }
-    const categoryQuery = queries.ProductsByCategory;
-    const result = await categoryQuery({ category });
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
-  },
-);
+function registerProductCatalogToolsOnce(): void {
+  if (_toolsRegistered) return;
+  _toolsRegistered = true;
 
-// Search
-interface ProductSearchParams extends Record<string, unknown> {
-  query: string;
-}
-registerTool<ProductSearchParams>(
-  'PRODUCT_CATALOGUE_SEARCH',
-  {
-    title: 'Search Products',
-    description: 'Search for products using a query string',
-    inputSchema: { query: z.string().min(1, 'Search query is required') },
-    schema: zGetApiProductsSearchResponse,
-    schemaName: 'GetApiProductsSearchResponse',
-    schemaDescription: 'Array of ProductCatalogItem',
-  },
-  async ({ query }) => {
-    const queries = ProductCatalog.Queries as ProductCatalogQueries;
-    if (queries?.ProductSearchResults == null) {
-      return {
-        content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductSearchResults is not available' }],
-        isError: true,
-      };
-    }
-    const searchQuery = queries.ProductSearchResults;
-    const result = await searchQuery({ query });
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
-  },
-);
+  // All products
+  registerTool<Record<string, unknown>>(
+    'PRODUCT_CATALOGUE_PRODUCTS',
+    {
+      title: 'Get All Products',
+      description: 'Fetches all products from the product catalog',
+      inputSchema: {},
+      schema: zGetApiProductsResponse,
+      schemaName: 'GetApiProductsResponse',
+      schemaDescription: 'Array of ProductCatalogItem',
+    },
+    async () => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.Products) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.Products is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.Products();
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
+    },
+  );
 
-// Details
-interface ProductDetailsParams extends Record<string, unknown> {
-  id: string;
+  // By category
+  interface ProductsByCategoryParams extends Record<string, unknown> {
+    category: string;
+  }
+  registerTool<ProductsByCategoryParams>(
+    'PRODUCT_CATALOGUE_PRODUCTS_BY_CATEGORY',
+    {
+      title: 'Get Products by Category',
+      description: 'Fetches products from a specific category',
+      inputSchema: { category: z.string().min(1, 'Category is required') },
+      schema: zGetApiProductsCategoryByCategoryResponse,
+      schemaName: 'GetApiProductsCategoryByCategoryResponse',
+      schemaDescription: 'Array of ProductCatalogItem',
+    },
+    async ({ category }) => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.ProductsByCategory) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductsByCategory is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.ProductsByCategory({ category });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
+    },
+  );
+
+  // Search
+  interface ProductSearchParams extends Record<string, unknown> {
+    query: string;
+  }
+  registerTool<ProductSearchParams>(
+    'PRODUCT_CATALOGUE_SEARCH',
+    {
+      title: 'Search Products',
+      description: 'Search for products using a query string',
+      inputSchema: { query: z.string().min(1, 'Search query is required') },
+      schema: zGetApiProductsSearchResponse,
+      schemaName: 'GetApiProductsSearchResponse',
+      schemaDescription: 'Array of ProductCatalogItem',
+    },
+    async ({ query }) => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.ProductSearchResults) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductSearchResults is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.ProductSearchResults({ query });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
+    },
+  );
+
+  // Details
+  interface ProductDetailsParams extends Record<string, unknown> {
+    id: string;
+  }
+  registerTool<ProductDetailsParams>(
+    'PRODUCT_CATALOGUE_PRODUCT_DETAILS',
+    {
+      title: 'Get Product Details',
+      description: 'Fetches detailed information about a specific product',
+      inputSchema: { id: z.string().min(1, 'Product ID is required') },
+      schema: zGetApiProductsByIdResponse,
+      schemaName: 'GetApiProductsByIdResponse',
+      schemaDescription: 'Single ProductCatalogItem',
+    },
+    async ({ id }) => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.ProductDetails) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductDetails is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.ProductDetails({ id });
+      if (result.data.product === null) {
+        return { content: [{ type: 'text' as const, text: `Product with ID "${id}" not found` }], isError: true };
+      }
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.product, null, 2) }] };
+    },
+  );
 }
-registerTool<ProductDetailsParams>(
-  'PRODUCT_CATALOGUE_PRODUCT_DETAILS',
-  {
-    title: 'Get Product Details',
-    description: 'Fetches detailed information about a specific product',
-    inputSchema: { id: z.string().min(1, 'Product ID is required') },
-    schema: zGetApiProductsByIdResponse,
-    schemaName: 'GetApiProductsByIdResponse',
-    schemaDescription: 'Single ProductCatalogItem',
-  },
-  async ({ id }) => {
-    const queries = ProductCatalog.Queries as ProductCatalogQueries;
-    if (queries?.ProductDetails == null) {
-      return {
-        content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductDetails is not available' }],
-        isError: true,
-      };
-    }
-    const detailsQuery = queries.ProductDetails;
-    const result = await detailsQuery({ id });
-    if (result.data.product === null) {
-      return { content: [{ type: 'text' as const, text: `Product with ID "${id}" not found` }], isError: true };
-    }
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.product, null, 2) }] };
+
+// registers tools on *first usage* of the integration
+export const ProductCatalog: Integration<'product-catalog', ProductCatalogQueries> = new Proxy(_ProductCatalog, {
+  get(target, prop, receiver) {
+    // First touch of ProductCatalog triggers tool registration
+    registerProductCatalogToolsOnce();
+    return Reflect.get(target, prop, receiver);
   },
-);
+});

package/templates/shopping-app/flows/shopping-assistant.flow.ts

@@ -19,7 +19,6 @@ import {
 
 import { AI, ProductCatalog, type DoChat, type ChatCompleted, type Products } from '../server/src/integrations';
 
-
 type ShoppingCriteriaEntered = Event<
   'ShoppingCriteriaEntered',
   {