create-auto-app 0.3.0 → 0.8.5

package/templates/shopping-app/.context/server/.context/auto-ia-scheme.json

@@ -0,0 +1,79 @@
+{
+  "components": {
+    "atoms": {
+      "items": {}
+    },
+    "molecules": {
+      "items": {
+        "ShoppingCriteriaInput": {
+          "description": "Input component for shoppers to describe their shopping criteria.",
+          "composition": {
+            "atoms": ["TextInput", "Button"],
+            "molecules": []
+          },
+          "specs": [
+            "allow shopper to describe their shopping needs in natural language",
+            "provide a text input for entering criteria",
+            "show examples of what to include (age, interests, budget)",
+            "show a button to submit the criteria"
+          ]
+        },
+        "SuggestedItemsList": {
+          "description": "Displays a list of suggested shopping items with quantity selectors.",
+          "composition": {
+            "atoms": ["Text", "QuantitySelector", "Button"],
+            "molecules": []
+          },
+          "specs": [
+            "display all suggested items with names and reasons",
+            "show quantity selectors for each item",
+            "have an 'Add to Cart' button for selected items",
+            "allow removing items from the suggestions"
+          ]
+        }
+      }
+    },
+    "organisms": {
+      "items": {
+        "ShoppingAssistant": {
+          "description": "Main component that manages the shopping criteria input and suggested items display.",
+          "composition": {
+            "molecules": ["ShoppingCriteriaInput", "SuggestedItemsList"]
+          },
+          "data_requirements": [
+            {
+              "type": "query",
+              "description": "Fetch suggested items based on shopper's criteria.",
+              "trigger": "When shopping criteria is entered.",
+              "details": {
+                "source": "AI integration",
+                "gql": "query GetSuggestedItems($sessionId: ID!) { suggestedItems(sessionId: $sessionId) { items { productId name quantity reason } } }"
+              }
+            }
+          ]
+        }
+      }
+    }
+  },
+  "pages": {
+    "ShoppingAssistantPage": {
+      "route": "/shopping-assistant",
+      "description": "Page for shoppers to interact with the shopping assistant.",
+      "layout": {
+        "organisms": ["ShoppingAssistant"]
+      },
+      "navigation": [],
+      "data_requirements": [
+        {
+          "type": "mutation",
+          "description": "Enter shopping criteria.",
+          "trigger": "When shopper submits their criteria.",
+          "details": {
+            "source": "User input",
+            "gql": "mutation EnterShoppingCriteria($input: EnterShoppingCriteriaInput!) { enterShoppingCriteria(input: $input) { success error { type message } } }"
+          }
+        }
+      ]
+    }
+  }
+}

package/templates/shopping-app/.context/server/server/package.json

@@ -6,7 +6,7 @@
   "scripts": {
     "start": "tsx --no-deprecation src/server.ts",
     "type-check": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "vitest run --reporter=dot",
     "dev": "tsx --no-deprecation src/server.ts"
   },
   "dependencies": {

package/templates/shopping-app/.context/server/server/scripts/generate-schema.ts

@@ -15,7 +15,7 @@ async function main() {
     const printedSchema = printSchema(schema);
 
     const contextDir = path.resolve(
-      '/Users/sam/WebstormProjects/top/auto-engineer/examples/shopping-app/.context/server',
+      '/Users/ramihatoum/WebstormProjects/xolvio/auto-engineer/examples/shopping-app/.context/server',
       '.context',
     );
     const schemaPath = path.join(contextDir, 'schema.graphql');

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/accepts-items-and-adds-to-their-cart/decide.specs.ts

@@ -38,7 +38,7 @@ describe('Seasonal Assistant | accepts items and adds to their cart', () => {
               { productId: 'prod-laptop-bag', quantity: 1 },
               { productId: 'prod-mtg-starter', quantity: 1 },
             ],
-            timestamp: new Date('2025-09-02T00:39:41.677Z'),
+            timestamp: new Date('2025-09-04T21:20:20.310Z'),
           },
         },
       ]);

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session/react.specs.ts

@@ -0,0 +1,51 @@
+import { describe, it, beforeEach } from 'vitest';
+import 'reflect-metadata';
+import { getInMemoryEventStore, type InMemoryEventStore, type CommandSender } from '@event-driven-io/emmett';
+import { type ReactorContext, ReactorSpecification } from '../../../shared';
+import { react } from './react';
+import type { ShoppingCriteriaEntered } from '../enters-shopping-criteria-into-assistant/events';
+import type { SuggestShoppingItems } from '../selects-items-relevant-to-the-shopping-criteria/commands';
+
+describe('SeasonalAssistant | CreatesAChatSession', () => {
+  let eventStore: InMemoryEventStore;
+  let given: ReactorSpecification<ShoppingCriteriaEntered, SuggestShoppingItems, ReactorContext>;
+  let messageBus: CommandSender;
+
+  beforeEach(() => {
+    eventStore = getInMemoryEventStore({});
+    given = ReactorSpecification.for<ShoppingCriteriaEntered, SuggestShoppingItems, ReactorContext>(
+      () => react({ eventStore, commandSender: messageBus }),
+      (commandSender) => {
+        messageBus = commandSender;
+        return {
+          eventStore,
+          commandSender,
+          database: eventStore.database,
+        };
+      },
+    );
+  });
+
+  it('should send SuggestShoppingItems when ShoppingCriteriaEntered is received', async () => {
+    await given([])
+      .when({
+        type: 'ShoppingCriteriaEntered',
+        data: {
+          sessionId: 'session-abc',
+          criteria:
+            'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
+          timestamp: new Date('2025-09-04T21:20:20.309Z'),
+        },
+      })
+
+      .then({
+        type: 'SuggestShoppingItems',
+        kind: 'Command',
+        data: {
+          sessionId: 'session-abc',
+          prompt:
+            'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
+        },
+      });
+  });
+});

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session/react.ts

@@ -0,0 +1,43 @@
+import { inMemoryReactor, type MessageHandlerResult, IllegalStateError } from '@event-driven-io/emmett';
+import type { ShoppingCriteriaEntered } from '../enters-shopping-criteria-into-assistant/events';
+import type { ReactorContext } from '../../../shared';
+
+export const react = ({ eventStore, commandSender }: ReactorContext) =>
+  inMemoryReactor<ShoppingCriteriaEntered>({
+    processorId: 'seasonal-assistant-creates-a-chat-session',
+    canHandle: ['ShoppingCriteriaEntered'],
+    connectionOptions: {
+      database: eventStore.database,
+    },
+    eachMessage: async (event, context): Promise<MessageHandlerResult> => {
+      /**
+       * ## IMPLEMENTATION INSTRUCTIONS ##
+       *
+       * - Inspect event data to determine if the command should be sent.
+       * - Replace the placeholder logic and \`throw\` below with real implementation.
+       * - Send one or more commands via: context.commandSender.send({...})
+       * - Optionally return a MessageHandlerResult for SKIP or error cases.
+       */
+
+      throw new IllegalStateError('Not yet implemented: react in response to ShoppingCriteriaEntered');
+
+      // Example:
+      // if (event.data.status !== 'expected') {
+      //   return {
+      //     type: 'SKIP',
+      //     reason: 'Condition not met',
+      //   };
+      // }
+
+      // await context.commandSender.send({
+      //   type: 'SuggestShoppingItems',
+      //   kind: 'Command',
+      //   data: {
+      //     // Map event fields to command fields here
+      //     // e.g., userId: event.data.userId,
+      //   },
+      // });
+
+      // return;
+    },
+  });

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session/register.ts

@@ -0,0 +1,24 @@
+import { type CommandSender, type EventSubscription, type InMemoryEventStore } from '@event-driven-io/emmett';
+import type { ShoppingCriteriaEntered } from '../enters-shopping-criteria-into-assistant/events';
+
+export async function register(messageBus: CommandSender & EventSubscription, eventStore: InMemoryEventStore) {
+  messageBus.subscribe(async (event: ShoppingCriteriaEntered) => {
+    /**
+     * ## IMPLEMENTATION INSTRUCTIONS ##
+     *
+     * - Replace the placeholder logic with the  real implementation.
+     * - Send one or more commands via: messageBus.send({...})
+     */
+
+    // await messageBus.send({
+    //   type: 'SuggestShoppingItems',
+    //   kind: 'Command',
+    //   data: {
+    //     // Map event fields to command fields here
+    //     // e.g., userId: event.data.userId,
+    //   },
+    // });
+
+    return;
+  }, 'ShoppingCriteriaEntered');
+}

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/creates-a-chat-session-/react.specs.ts

@@ -34,7 +34,7 @@ describe('SeasonalAssistant | CreatesAChatSession', () => {
           sessionId: 'session-abc',
           criteria:
             'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
-          timestamp: new Date('2025-09-02T00:39:41.677Z'),
+          timestamp: new Date('2025-09-04T20:53:48.700Z'),
         },
       })
 

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant/decide.specs.ts

@@ -30,7 +30,7 @@ describe('Seasonal Assistant | enters shopping criteria into assistant', () => {
             sessionId: 'shopper-123',
             criteria:
               'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
-            timestamp: new Date('2025-09-02T00:39:41.677Z'),
+            timestamp: new Date('2025-09-04T21:20:20.309Z'),
           },
         },
       ]);

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/commands.ts

@@ -0,0 +1,8 @@
+import { Command } from '@event-driven-io/emmett';
+export type SuggestShoppingItems = Command<
+  'SuggestShoppingItems',
+  {
+    sessionId: string;
+    prompt: string;
+  }
+>;

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/decide.specs.ts

@@ -0,0 +1,101 @@
+import { describe, it } from 'vitest';
+import { DeciderSpecification } from '@event-driven-io/emmett';
+import { decide } from './decide';
+import { evolve } from './evolve';
+import { initialState } from './state';
+
+describe('Seasonal Assistant | selects items relevant to the shopping criteria', () => {
+  const given = DeciderSpecification.for({
+    decide,
+    evolve,
+    initialState,
+  });
+
+  it('should emit ShoppingItemsSuggested for valid SuggestShoppingItems', () => {
+    given([
+      {
+        type: 'undefined',
+        data: {
+          products: [
+            {
+              productId: 'prod-soccer-ball',
+              name: 'Super Soccer Ball',
+              category: 'Sports',
+              price: 10,
+              tags: ['soccer', 'sports'],
+              imageUrl: 'https://example.com/soccer-ball.jpg',
+            },
+            {
+              productId: 'prod-craft-kit',
+              name: 'Deluxe Craft Kit',
+              category: 'Arts & Crafts',
+              price: 25,
+              tags: ['crafts', 'art', 'creative'],
+              imageUrl: 'https://example.com/craft-kit.jpg',
+            },
+            {
+              productId: 'prod-laptop-bag',
+              name: 'Tech Laptop Backpack',
+              category: 'School Supplies',
+              price: 45,
+              tags: ['computers', 'tech', 'school'],
+              imageUrl: 'https://example.com/laptop-bag.jpg',
+            },
+            {
+              productId: 'prod-mtg-starter',
+              name: 'Magic the Gathering Starter Set',
+              category: 'Games',
+              price: 30,
+              tags: ['magic', 'tcg', 'games'],
+              imageUrl: 'https://example.com/mtg-starter.jpg',
+            },
+          ],
+        },
+      },
+    ])
+      .when({
+        type: 'SuggestShoppingItems',
+        data: {
+          sessionId: 'session-abc',
+          prompt:
+            'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
+        },
+        metadata: { now: new Date() },
+      })
+
+      .then([
+        {
+          type: 'ShoppingItemsSuggested',
+          data: {
+            sessionId: 'session-abc',
+            suggestedItems: [
+              {
+                productId: 'prod-soccer-ball',
+                name: 'Super Soccer Ball',
+                quantity: 1,
+                reason: 'Perfect for your daughter who loves soccer',
+              },
+              {
+                productId: 'prod-craft-kit',
+                name: 'Deluxe Craft Kit',
+                quantity: 1,
+                reason: 'Great for creative activities and crafts',
+              },
+              {
+                productId: 'prod-laptop-bag',
+                name: 'Tech Laptop Backpack',
+                quantity: 1,
+                reason: "Essential for your son's school computer needs",
+              },
+              {
+                productId: 'prod-mtg-starter',
+                name: 'Magic the Gathering Starter Set',
+                quantity: 1,
+                reason: 'Ideal starter set for Magic the Gathering enthusiasts',
+              },
+            ],
+          },
+        },
+      ]);
+  });
+});

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/decide.ts

@@ -0,0 +1,42 @@
+import { IllegalStateError } from '@event-driven-io/emmett';
+import type { State } from './state';
+import type { SuggestShoppingItems } from './commands';
+import type { ShoppingItemsSuggested } from './events';
+import type { Products } from '@auto-engineer/product-catalog-integration';
+
+export const decide = (command: SuggestShoppingItems, state: State, products?: Products): ShoppingItemsSuggested => {
+  switch (command.type) {
+    case 'SuggestShoppingItems': {
+      /**
+       * ## IMPLEMENTATION INSTRUCTIONS ##
+       *
+       * This command requires evaluating prior state to determine if it can proceed.
+       *
+       * You should:
+       * - Validate the command input fields
+       * - Inspect the current domain `state` to determine if the command is allowed
+       * - Use `products` (integration result) to enrich or filter the output
+       * - If invalid, throw one of the following domain errors: `NotFoundError`, `ValidationError`, or `IllegalStateError`
+       * - If valid, return one or more events with the correct structure
+       *
+       * ⚠️ Only read from inputs — never mutate them. `evolve.ts` handles state updates.
+       *
+       * Integration result shape (Products):
+       * products?.data = {
+       *   products: Array<{
+       *     productId: string; name;
+       *   }>;
+       * }
+       */
+
+      // return {
+      //   type: 'ShoppingItemsSuggested',
+      //   data: { ...command.data },
+      // } as ShoppingItemsSuggested;
+
+      throw new IllegalStateError('Not yet implemented: ' + command.type);
+    }
+    default:
+      throw new IllegalStateError('Unexpected command type: ' + command.type);
+  }
+};

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/events.ts

@@ -0,0 +1,9 @@
+import type { Event } from '@event-driven-io/emmett';
+
+export type ShoppingItemsSuggested = Event<
+  'ShoppingItemsSuggested',
+  {
+    sessionId: string;
+    suggestedItems: Array<{ productId: string; name: string; quantity: number; reason: string }>;
+  }
+>;

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/evolve.ts

@@ -0,0 +1,28 @@
+import type { State } from './state';
+import type { ShoppingItemsSuggested } from './events';
+
+/**
+ * ## IMPLEMENTATION INSTRUCTIONS ##
+ *
+ * This function defines how the domain state evolves in response to events.
+ *
+ * Guidelines:
+ * - Apply only the **minimal** necessary changes for future decisions in `decide.ts`.
+ * - Ignore any event fields not required for decision-making logic.
+ * - If the event doesn’t change decision-relevant state, return the existing `state`.
+ * - Prefer immutability: always return a **new state object**.
+ * - Avoid spreading all of `event.data` unless all fields are relevant.
+ */
+
+export const evolve = (state: State, event: ShoppingItemsSuggested): State => {
+  switch (event.type) {
+    case 'ShoppingItemsSuggested': {
+      // TODO: Update state based on ShoppingItemsSuggested
+      return {
+        ...state,
+      };
+    }
+    default:
+      return state;
+  }
+};

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/handle.ts

@@ -0,0 +1,52 @@
+import '@auto-engineer/product-catalog-integration';
+
+import { AI } from '@auto-engineer/ai-integration';
+
+import { Products } from '@auto-engineer/product-catalog-integration';
+
+import { CommandHandler, type EventStore, type MessageHandlerResult } from '@event-driven-io/emmett';
+import { evolve } from './evolve';
+import { initialState } from './state';
+import { decide } from './decide';
+import type { SuggestShoppingItems } from './commands';
+
+/**
+ * ## IMPLEMENTATION INSTRUCTIONS ##
+ * add the following to the DoChat: schemaName: Products, systemPrompt: use the PRODUCT_CATALOGUE_PRODUCTS MCP tool to get product data
+ */
+
+const handler = CommandHandler({
+  evolve,
+  initialState,
+});
+
+export const handle = async (eventStore: EventStore, command: SuggestShoppingItems): Promise<MessageHandlerResult> => {
+  const streamId = `shopping-session-${command.data.sessionId}`;
+
+  try {
+    // TODO: Map fields from the incoming command to this integration input.
+    // - Use relevant fields from `command.data` to populate the required inputs below.
+    // - Some fields may require transformation or enrichment.
+    // - If additional context is needed, construct it here.
+    // const products: Products | undefined = await AI.Commands?.DoChat<Products>({
+    //   type: 'DoChat',
+    //   data: {
+    //    // sessionId: ???
+    // prompt: ???
+    // systemPrompt: ???
+    // schemaName: ???
+    //   },
+    // });
+
+    await handler(eventStore, streamId, (state) =>
+      // TODO: add products as a parameter to decide once implemented above
+      decide(command, state /* products */),
+    );
+    return; // success (returns void)
+  } catch (error: any) {
+    return {
+      type: 'SKIP',
+      reason: `Command failed: ${error?.message ?? 'Unknown'}`,
+    };
+  }
+};

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/mutation.resolver.ts

@@ -0,0 +1,25 @@
+import { Mutation, Resolver, Arg, Ctx, Field, InputType } from 'type-graphql';
+import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+@InputType()
+export class SuggestShoppingItemsInput {
+  @Field(() => String)
+  sessionId!: string;
+  @Field(() => String)
+  prompt!: string;
+}
+
+@Resolver()
+export class SuggestShoppingItemsResolver {
+  @Mutation(() => MutationResponse)
+  async suggestShoppingItems(
+    @Arg('input', () => SuggestShoppingItemsInput) input: SuggestShoppingItemsInput,
+    @Ctx() ctx: GraphQLContext,
+  ): Promise<MutationResponse> {
+    return await sendCommand(ctx.messageBus, {
+      type: 'SuggestShoppingItems',
+      kind: 'Command',
+      data: { ...input },
+    });
+  }
+}

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/register.ts

@@ -0,0 +1,7 @@
+import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
+import { handle } from './handle';
+import type { SuggestShoppingItems } from './commands';
+
+export function register(messageBus: CommandProcessor, eventStore: EventStore) {
+  messageBus.handle((command: SuggestShoppingItems) => handle(eventStore, command), 'SuggestShoppingItems');
+}

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria/state.ts

@@ -0,0 +1,47 @@
+/**
+ * ## IMPLEMENTATION INSTRUCTIONS ##
+ *
+ * Define the shape of the domain state for the current slice below. This state is used by `decide.ts`
+ * to determine whether a command is valid.
+ *
+ * The state is evolved over time by applying domain events (in `evolve.ts`).
+ * Each event updates the state incrementally based on business rules.
+ *
+ * Guidelines:
+ * - Include only fields that are **read** during command validation.
+ * - Use discriminated unions (e.g., `status: 'Pending' | 'Done'`) to model state transitions.
+ * - Prefer primitive types: `string`, `boolean`, `number`.
+ * - Use objects or maps only when structure is essential for decision logic.
+ *
+ * Do NOT include:
+ * - Redundant data already emitted in events unless required to enforce business rules.
+ * - Fields used only for projections, UI, or query purposes.
+ *
+ * ### Example (for a Task domain):
+ *
+ * ```ts
+ * export type PendingTask = {
+ *   status: 'Pending';
+ * };
+ *
+ * export type InProgressTask = {
+ *   status: 'InProgress';
+ *   startedAt: string;
+ * };
+ *
+ * export type CompletedTask = {
+ *   status: 'Completed';
+ *   completedAt: string;
+ * };
+ *
+ * export type State = PendingTask | InProgressTask | CompletedTask;
+ * ```
+ */
+
+// TODO: Replace with a discriminated union of domain states for the current slice
+export type State = {};
+
+// TODO: Replace the Return with the initial domain state of the current slice
+export const initialState = (): State => {
+  return {};
+};

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria-/decide.specs.ts

@@ -12,7 +12,47 @@ describe('Seasonal Assistant | selects items relevant to the shopping criteria
   });
 
   it('should emit ShoppingItemsSuggested for valid SuggestShoppingItems', () => {
-    given([])
+    given([
+      {
+        type: 'undefined',
+        data: {
+          products: [
+            {
+              productId: 'prod-soccer-ball',
+              name: 'Super Soccer Ball',
+              category: 'Sports',
+              price: 10,
+              tags: ['soccer', 'sports'],
+              imageUrl: 'https://example.com/soccer-ball.jpg',
+            },
+            {
+              productId: 'prod-craft-kit',
+              name: 'Deluxe Craft Kit',
+              category: 'Arts & Crafts',
+              price: 25,
+              tags: ['crafts', 'art', 'creative'],
+              imageUrl: 'https://example.com/craft-kit.jpg',
+            },
+            {
+              productId: 'prod-laptop-bag',
+              name: 'Tech Laptop Backpack',
+              category: 'School Supplies',
+              price: 45,
+              tags: ['computers', 'tech', 'school'],
+              imageUrl: 'https://example.com/laptop-bag.jpg',
+            },
+            {
+              productId: 'prod-mtg-starter',
+              name: 'Magic the Gathering Starter Set',
+              category: 'Games',
+              price: 30,
+              tags: ['magic', 'tcg', 'games'],
+              imageUrl: 'https://example.com/mtg-starter.jpg',
+            },
+          ],
+        },
+      },
+    ])
       .when({
         type: 'SuggestShoppingItems',
         data: {

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria-/decide.ts

@@ -10,7 +10,7 @@ export const decide = (command: SuggestShoppingItems, state: State, products?: P
       /**
        * ## IMPLEMENTATION INSTRUCTIONS ##
        *
-       * This command can directly emit one or more events based on the input.
+       * This command requires evaluating prior state to determine if it can proceed.
        *
        * You should:
        * - Validate the command input fields
@@ -20,6 +20,14 @@ export const decide = (command: SuggestShoppingItems, state: State, products?: P
        * - If valid, return one or more events with the correct structure
        *
        * ⚠️ Only read from inputs — never mutate them. `evolve.ts` handles state updates.
+       *
+       * Integration result shape (Products):
+       * products?.data = {
+       *   type: "Products";
+       *   products: Array<{
+       *     productId: string; name;
+       *   }>;
+       * }
        */
 
       // return {

package/templates/shopping-app/.context/server/server/src/domain/flows/seasonal-assistant/selects-items-relevant-to-the-shopping-criteria-/handle.ts

@@ -31,7 +31,10 @@ export const handle = async (eventStore: EventStore, command: SuggestShoppingIte
     // const products: Products | undefined = await AI.Commands?.DoChat<Products>({
     //   type: 'DoChat',
     //   data: {
-    //
+    //    // sessionId: ???
+    // prompt: ???
+    // systemPrompt: ???
+    // schemaName: ???
     //   },
     // });