@falai/agent 0.9.0-alpha-1 → 0.9.0

package/examples/core-concepts/modern-streaming-api.ts

@@ -0,0 +1,309 @@
+/**
+ * Example: Modern Streaming API
+ * 
+ * This example demonstrates the new agent.stream() method introduced in the
+ * ResponseModal refactor. The modern API provides automatic session management
+ * and a simpler interface compared to the legacy respondStream() method.
+ */
+
+import {
+  Agent,
+  AnthropicProvider,
+  OpenAIProvider,
+} from "../../src/index";
+
+// Context type for our examples
+interface UserContext {
+  userId: string;
+  preferences: {
+    language?: string;
+    verbosity: "concise" | "detailed";
+  };
+}
+
+async function basicModernStreaming() {
+  console.log("\n🚀 Example 1: Basic Modern Streaming API\n");
+
+  const provider = new AnthropicProvider({
+    apiKey: process.env.ANTHROPIC_API_KEY || "",
+    model: "claude-sonnet-4-5",
+  });
+
+  const agent = new Agent<UserContext, unknown>({
+    name: "ModernStreamingAgent",
+    description: "Demonstrates the new stream() API",
+    context: {
+      userId: "user123",
+      preferences: {
+        language: "English",
+        verbosity: "concise",
+      },
+    },
+    provider,
+  });
+
+  try {
+    console.log("📤 Using modern stream() API...\n");
+    console.log("Response: ");
+
+    // NEW: Simple streaming with automatic session management
+    for await (const chunk of agent.stream("What is machine learning?")) {
+      if (chunk.delta) {
+        process.stdout.write(chunk.delta);
+      }
+
+      if (chunk.done) {
+        console.log("\n\n✅ Stream complete!");
+        console.log(`📊 Session has ${agent.session.getHistory().length} messages`);
+        console.log("💡 Session history was automatically managed!");
+      }
+    }
+  } catch (error) {
+    console.error("❌ Error:", error);
+  }
+}
+
+async function streamingWithOptions() {
+  console.log("\n🚀 Example 2: Streaming with Options\n");
+
+  const provider = new OpenAIProvider({
+    apiKey: process.env.OPENAI_API_KEY || "",
+    model: "gpt-4",
+  });
+
+  const agent = new Agent<UserContext, unknown>({
+    name: "OptionsStreamingAgent",
+    description: "Demonstrates streaming with options",
+    context: {
+      userId: "user456",
+      preferences: {
+        language: "English",
+        verbosity: "detailed",
+      },
+    },
+    provider,
+  });
+
+  try {
+    console.log("📤 Streaming with context override and abort signal...\n");
+    console.log("Response: ");
+
+    // Create abort controller for cancellation
+    const abortController = new AbortController();
+    
+    // Cancel after 10 seconds
+    setTimeout(() => {
+      console.log("\n⚠️ Aborting stream...");
+      abortController.abort();
+    }, 10000);
+
+    // Stream with options
+    for await (const chunk of agent.stream("Explain quantum computing in detail", {
+      contextOverride: {
+        preferences: { verbosity: "concise" } // Override to be more concise
+      },
+      signal: abortController.signal
+    })) {
+      if (chunk.delta) {
+        process.stdout.write(chunk.delta);
+      }
+
+      if (chunk.done) {
+        console.log("\n\n✅ Stream complete!");
+        console.log("💡 Context was overridden for this response only");
+        clearTimeout();
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      console.log("\n🛑 Stream was successfully aborted!");
+    } else {
+      console.error("❌ Error:", error);
+    }
+  }
+}
+
+async function conversationFlow() {
+  console.log("\n🚀 Example 3: Multi-turn Conversation Flow\n");
+
+  const provider = new AnthropicProvider({
+    apiKey: process.env.ANTHROPIC_API_KEY || "",
+    model: "claude-sonnet-4-5",
+  });
+
+  const agent = new Agent<UserContext, unknown>({
+    name: "ConversationAgent",
+    description: "Demonstrates multi-turn conversations",
+    context: {
+      userId: "user789",
+      preferences: {
+        language: "English",
+        verbosity: "detailed",
+      },
+    },
+    provider,
+  });
+
+  const messages = [
+    "What is TypeScript?",
+    "How is it different from JavaScript?",
+    "Can you give me a simple example?",
+    "Thank you for the explanation!"
+  ];
+
+  try {
+    console.log("📤 Multi-turn conversation with automatic session management...\n");
+
+    for (let i = 0; i < messages.length; i++) {
+      console.log(`\n${"=".repeat(60)}`);
+      console.log(`💬 Turn ${i + 1}: ${messages[i]}`);
+      console.log(`${"=".repeat(60)}`);
+      console.log("Response: ");
+
+      // Each stream() call automatically manages the session
+      for await (const chunk of agent.stream(messages[i])) {
+        if (chunk.delta) {
+          process.stdout.write(chunk.delta);
+        }
+
+        if (chunk.done) {
+          console.log(`\n📊 Session now has ${agent.session.getHistory().length} messages`);
+        }
+      }
+    }
+
+    console.log("\n✅ Conversation complete!");
+    console.log("💡 All session management was handled automatically");
+    console.log(`📊 Final session has ${agent.session.getHistory().length} messages`);
+
+  } catch (error) {
+    console.error("❌ Error:", error);
+  }
+}
+
+async function migrationComparison() {
+  console.log("\n🚀 Example 4: Migration from respondStream() to stream()\n");
+
+  const provider = new AnthropicProvider({
+    apiKey: process.env.ANTHROPIC_API_KEY || "",
+    model: "claude-sonnet-4-5",
+  });
+
+  const agent = new Agent<UserContext, unknown>({
+    name: "MigrationAgent",
+    description: "Shows migration from old to new API",
+    context: {
+      userId: "migration-user",
+      preferences: {
+        language: "English",
+        verbosity: "concise",
+      },
+    },
+    provider,
+  });
+
+  const userMessage = "What are the benefits of TypeScript?";
+
+  try {
+    // ========================================================================
+    // OLD WAY: respondStream() - Manual session management
+    // ========================================================================
+    console.log("🔸 OLD WAY: Using respondStream() with manual session management");
+    console.log("Code: agent.respondStream({ history: agent.session.getHistory() })");
+    console.log("Response: ");
+
+    // Manual session management required
+    await agent.session.addMessage("user", userMessage);
+    
+    let oldResponse = "";
+    for await (const chunk of agent.respondStream({ 
+      history: agent.session.getHistory() 
+    })) {
+      if (chunk.delta) {
+        process.stdout.write(chunk.delta);
+        oldResponse += chunk.delta;
+      }
+
+      if (chunk.done) {
+        // Manual history update required
+        await agent.session.addMessage("assistant", oldResponse);
+        console.log("\n   ✅ Manual session update completed");
+      }
+    }
+
+    console.log("\n" + "=".repeat(60));
+
+    // ========================================================================
+    // NEW WAY: stream() - Automatic session management
+    // ========================================================================
+    console.log("🔸 NEW WAY: Using stream() with automatic session management");
+    console.log("Code: agent.stream('message')");
+    console.log("Response: ");
+
+    // Automatic session management - just pass the message!
+    for await (const chunk of agent.stream("Can you elaborate on the type safety benefits?")) {
+      if (chunk.delta) {
+        process.stdout.write(chunk.delta);
+      }
+
+      if (chunk.done) {
+        console.log("\n   ✅ Automatic session update - no manual work needed!");
+      }
+    }
+
+    console.log("\n📊 Migration Benefits:");
+    console.log("   ✅ Simpler API: agent.stream('message') vs complex parameters");
+    console.log("   ✅ Automatic session management - no manual addMessage() calls");
+    console.log("   ✅ Same performance and features as respondStream()");
+    console.log("   ✅ Backward compatibility - respondStream() still works");
+    console.log("   ✅ Consistent with chat() API patterns");
+
+    console.log(`\n📊 Final session has ${agent.session.getHistory().length} messages`);
+
+  } catch (error) {
+    console.error("❌ Error:", error);
+  }
+}
+
+async function main() {
+  console.log("🚀 Modern Streaming API Examples");
+  console.log("=".repeat(60));
+
+  const examples = [
+    { name: "Basic Modern Streaming", fn: basicModernStreaming },
+    { name: "Streaming with Options", fn: streamingWithOptions },
+    { name: "Multi-turn Conversation", fn: conversationFlow },
+    { name: "Migration Comparison", fn: migrationComparison },
+  ];
+
+  console.log("\nAvailable Examples:");
+  examples.forEach((ex, i) => {
+    console.log(`  ${i + 1}. ${ex.name}`);
+  });
+
+  console.log("\n💡 Key Benefits of Modern stream() API:");
+  console.log("   - Simple interface: agent.stream('message')");
+  console.log("   - Automatic session management");
+  console.log("   - No manual history updates needed");
+  console.log("   - Same performance as respondStream()");
+  console.log("   - Full backward compatibility maintained");
+
+  console.log("\n" + "=".repeat(60));
+
+  // Run examples if API key is available
+  if (process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY) {
+    await basicModernStreaming();
+    await migrationComparison();
+  } else {
+    console.log(
+      "\n⚠️  Set ANTHROPIC_API_KEY or OPENAI_API_KEY to run examples."
+    );
+  }
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}
+
+export { main };

package/examples/core-concepts/schema-driven-extraction.ts

@@ -24,7 +24,7 @@ interface UserProfileData {
 }
 
 // Define a tool that uses the collected data
-const saveUserProfile: Tool<unknown, [], string, UserProfileData> = {
+const saveUserProfile: Tool<unknown, UserProfileData, [], string> = {
   id: "save_user_profile",
   description: "Save the collected user profile information",
   parameters: {
@@ -37,24 +37,12 @@ const saveUserProfile: Tool<unknown, [], string, UserProfileData> = {
     // Simulate saving to database
     console.log("Profile data:", data);
 
-    const userData = data as Partial<UserProfileData>;
     return {
-      data: `Profile saved successfully! Welcome ${userData?.name}!`,
+      data: `Profile saved successfully! Welcome ${data?.name}!`,
     };
   },
 };
 
-// Create the agent
-const agent = new Agent({
-  name: "ProfileBot",
-  description:
-    "A bot that collects user profile information using schema-driven extraction",
-  provider: new GeminiProvider({
-    apiKey: process.env.GEMINI_API_KEY!,
-    model: "models/gemini-2.5-flash",
-  }),
-});
-
 // Define the schema for data validation and extraction
 const userProfileSchema = {
   type: "object",
@@ -98,11 +86,27 @@ const userProfileSchema = {
   required: ["name", "email"],
 };
 
+// Create the agent with agent-level schema
+const agent = new Agent<unknown, UserProfileData>({
+  name: "ProfileBot",
+  description:
+    "A bot that collects user profile information using schema-driven extraction",
+  provider: new GeminiProvider({
+    apiKey: process.env.GEMINI_API_KEY!,
+    model: "models/gemini-2.5-flash",
+  }),
+  // NEW: Agent-level schema definition
+  schema: userProfileSchema,
+});
+
 // Create a route that collects profile information step by step
-agent.createRoute<UserProfileData>({
+agent.createRoute({
   title: "User Profile Collection",
   description: "Collect comprehensive user profile information",
-  schema: userProfileSchema,
+  // NEW: Required fields for route completion (instead of schema)
+  requiredFields: ["name", "email"],
+  // NEW: Optional fields that enhance the experience
+  optionalFields: ["age", "interests", "preferredContact", "newsletterOptIn"],
   // Use sequential steps for a linear flow with smart skipIf conditions
   steps: [
     {

package/examples/core-concepts/session-management.ts

@@ -43,7 +43,7 @@ interface PaymentData {
 }
 
 // Tools for order processing
-const createOrder: Tool<unknown, [], string, OrderData> = {
+const createOrder: Tool<unknown, UnifiedOrderData, [], string> = {
   id: "create_order",
   description: "Create a new order from the collected order data",
   parameters: {
@@ -52,8 +52,7 @@ const createOrder: Tool<unknown, [], string, OrderData> = {
   },
   handler: ({ data }) => {
     const orderId = `ORD-${Date.now()}`;
-    const orderData = data as Partial<OrderData>;
-    console.log(`Creating order ${orderId} for ${orderData?.customerName}`);
+    console.log(`Creating order ${orderId} for ${data?.customerName}`);
 
     return {
       data: `Order ${orderId} created successfully!`,
@@ -64,7 +63,7 @@ const createOrder: Tool<unknown, [], string, OrderData> = {
   },
 };
 
-const processPayment: Tool<unknown, [], string, PaymentData> = {
+const processPayment: Tool<unknown, UnifiedOrderData, [], string> = {
   id: "process_payment",
   description: "Process payment for an order",
   parameters: {
@@ -72,15 +71,14 @@ const processPayment: Tool<unknown, [], string, PaymentData> = {
     properties: {},
   },
   handler: ({ data }) => {
-    const paymentData = data as Partial<PaymentData>;
-    console.log(`Processing payment for order ${paymentData?.orderId}`);
+    console.log(`Processing payment for order ${data?.orderId}`);
 
     // Simulate payment processing
     const success = Math.random() > 0.1; // 90% success rate
 
     if (success) {
       return {
-        data: `Payment processed successfully! Order ${paymentData?.orderId} is now confirmed.`,
+        data: `Payment processed successfully! Order ${data?.orderId} is now confirmed.`,
         dataUpdate: {
           confirmed: true,
         },
@@ -96,8 +94,31 @@ const processPayment: Tool<unknown, [], string, PaymentData> = {
   },
 };
 
-// Create agent with persistence
-const agent = new Agent({
+// Define unified data schema for all order-related interactions
+interface UnifiedOrderData extends OrderData, PaymentData {}
+
+const orderSchema = {
+  type: "object",
+  properties: {
+    // Order fields
+    customerName: { type: "string" },
+    productType: { type: "string", enum: ["laptop", "phone", "tablet"] },
+    budget: { type: "number", minimum: 100 },
+    preferredColor: { type: "string" },
+    urgentDelivery: { type: "boolean" },
+    orderId: { type: "string" },
+    // Payment fields
+    paymentMethod: {
+      type: "string",
+      enum: ["credit_card", "paypal", "bank_transfer"],
+    },
+    amount: { type: "number" },
+    confirmed: { type: "boolean" },
+  },
+};
+
+// Create agent with persistence and agent-level schema
+const agent = new Agent<unknown, UnifiedOrderData>({
   name: "OrderBot",
   description:
     "A bot that handles multi-step order processing with session management",
@@ -105,27 +126,21 @@ const agent = new Agent({
     apiKey: process.env.GEMINI_API_KEY!,
     model: "models/gemini-2.5-flash",
   }),
+  // NEW: Agent-level schema
+  schema: orderSchema,
   persistence: {
     adapter: new MemoryAdapter(), // In production, use RedisAdapter, PrismaAdapter, etc.
   },
 });
 
 // Order collection route with sequential steps
-agent.createRoute<OrderData>({
+agent.createRoute({
   title: "Product Order",
   description: "Collect order details and create an order",
-  schema: {
-    type: "object",
-    properties: {
-      customerName: { type: "string" },
-      productType: { type: "string", enum: ["laptop", "phone", "tablet"] },
-      budget: { type: "number", minimum: 100 },
-      preferredColor: { type: "string" },
-      urgentDelivery: { type: "boolean" },
-      orderId: { type: "string" },
-    },
-    required: ["customerName", "productType", "budget"],
-  },
+  // NEW: Required fields for route completion
+  requiredFields: ["customerName", "productType", "budget"],
+  // NEW: Optional fields that enhance the experience
+  optionalFields: ["preferredColor", "urgentDelivery", "orderId"],
   // Sequential steps for order collection
   steps: [
     {
@@ -133,7 +148,7 @@ agent.createRoute<OrderData>({
       description: "Ask for customer name",
       prompt: "Hi! I'd like to help you place an order. What's your name?",
       collect: ["customerName"],
-      skipIf: (data: Partial<OrderData>) => !!data.customerName,
+      skipIf: (data: Partial<UnifiedOrderData>) => !!data.customerName,
     },
     {
       id: "ask_product",
@@ -141,7 +156,7 @@ agent.createRoute<OrderData>({
       prompt: "What would you like to order? (laptop, phone, or tablet)",
       collect: ["productType"],
       requires: ["customerName"],
-      skipIf: (data: Partial<OrderData>) => !!data.productType,
+      skipIf: (data: Partial<UnifiedOrderData>) => !!data.productType,
     },
     {
       id: "ask_budget",
@@ -149,7 +164,7 @@ agent.createRoute<OrderData>({
       prompt: "What's your budget for this purchase?",
       collect: ["budget"],
       requires: ["customerName", "productType"],
-      skipIf: (data: Partial<OrderData>) => data.budget !== undefined,
+      skipIf: (data: Partial<UnifiedOrderData>) => data.budget !== undefined,
     },
     {
       id: "ask_color",
@@ -157,7 +172,7 @@ agent.createRoute<OrderData>({
       prompt: "Do you have a preferred color?",
       collect: ["preferredColor"],
       requires: ["customerName", "productType", "budget"],
-      skipIf: (data: Partial<OrderData>) => !!data.preferredColor,
+      skipIf: (data: Partial<UnifiedOrderData>) => !!data.preferredColor,
     },
     {
       id: "ask_urgent",
@@ -165,7 +180,7 @@ agent.createRoute<OrderData>({
       prompt: "Do you need urgent delivery?",
       collect: ["urgentDelivery"],
       requires: ["customerName", "productType", "budget"],
-      skipIf: (data: Partial<OrderData>) => data.urgentDelivery !== undefined,
+      skipIf: (data: Partial<UnifiedOrderData>) => data.urgentDelivery !== undefined,
     },
     {
       id: "create_order",
@@ -182,22 +197,13 @@ agent.createRoute<OrderData>({
 });
 
 // Payment route with sequential steps
-agent.createRoute<PaymentData>({
+agent.createRoute({
   title: "Payment Processing",
   description: "Process payment for an order",
-  schema: {
-    type: "object",
-    properties: {
-      orderId: { type: "string" },
-      paymentMethod: {
-        type: "string",
-        enum: ["credit_card", "paypal", "bank_transfer"],
-      },
-      amount: { type: "number" },
-      confirmed: { type: "boolean" },
-    },
-    required: ["orderId", "paymentMethod", "amount"],
-  },
+  // NEW: Required fields for route completion
+  requiredFields: ["orderId", "paymentMethod", "amount"],
+  // NEW: Optional fields
+  optionalFields: ["confirmed"],
   // Sequential steps for payment processing
   steps: [
     {
@@ -206,7 +212,7 @@ agent.createRoute<PaymentData>({
       prompt:
         "Now let's process payment for your order. What payment method would you prefer?",
       collect: ["paymentMethod"],
-      skipIf: (data: Partial<PaymentData>) => !!data.paymentMethod,
+      skipIf: (data: Partial<UnifiedOrderData>) => !!data.paymentMethod,
     },
     {
       id: "ask_amount",
@@ -214,7 +220,7 @@ agent.createRoute<PaymentData>({
       prompt: "What's the payment amount?",
       collect: ["amount"],
       requires: ["paymentMethod"],
-      skipIf: (data: Partial<PaymentData>) => data.amount !== undefined,
+      skipIf: (data: Partial<UnifiedOrderData>) => data.amount !== undefined,
     },
     {
       id: "process_payment",
@@ -232,13 +238,15 @@ async function demonstrateSessionManagement() {
   console.log("=== Automatic Session Management Demo ===\n");
 
   // Create agent with automatic session management
-  const sessionAgent = new Agent({
+  const sessionAgent = new Agent<unknown, UnifiedOrderData>({
     name: "OrderBot",
     description: "A bot that handles multi-step order processing",
     provider: new GeminiProvider({
       apiKey: process.env.GEMINI_API_KEY!,
       model: "models/gemini-2.5-flash",
     }),
+    // NEW: Agent-level schema
+    schema: orderSchema,
     persistence: {
       adapter: new MemoryAdapter(),
     },
@@ -258,7 +266,7 @@ async function demonstrateSessionManagement() {
 
   console.log("Bot:", response1.message);
   console.log("Session ID:", sessionAgent.session.id);
-  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<OrderData>(), null, 2));
+  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<UnifiedOrderData>(), null, 2));
   console.log("History length:", sessionAgent.session.getHistory().length);
   console.log();
 
@@ -269,7 +277,7 @@ async function demonstrateSessionManagement() {
   const response2 = await sessionAgent.chat("My budget is $1500");
 
   console.log("Bot:", response2.message);
-  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<OrderData>(), null, 2));
+  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<UnifiedOrderData>(), null, 2));
   console.log("History length:", sessionAgent.session.getHistory().length);
   console.log();
 
@@ -280,7 +288,7 @@ async function demonstrateSessionManagement() {
   const response3 = await sessionAgent.chat("I want black color and urgent delivery please");
 
   console.log("Bot:", response3.message);
-  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<OrderData>(), null, 2));
+  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<UnifiedOrderData>(), null, 2));
   console.log("Route complete:", response3.isRouteComplete);
   console.log("History length:", sessionAgent.session.getHistory().length);
   console.log();
@@ -292,7 +300,7 @@ async function demonstrateSessionManagement() {
   const response4 = await sessionAgent.chat("I'll pay with credit card, amount is $1599");
 
   console.log("Bot:", response4.message);
-  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<PaymentData>(), null, 2));
+  console.log("Session data:", JSON.stringify(sessionAgent.session.getData<UnifiedOrderData>(), null, 2));
   console.log("Route complete:", response4.isRouteComplete);
   console.log("Final history length:", sessionAgent.session.getHistory().length);
 }
@@ -303,7 +311,7 @@ async function demonstrateSessionPersistence() {
 
   // Create agent with specific sessionId for demonstration
   const sessionId = "demo-session-456";
-  const persistentAgent = new Agent<OrderContext>({
+  const persistentAgent = new Agent<OrderContext, UnifiedOrderData>({
     name: "Order Assistant",
     description: "Help customers place orders with automatic persistence",
     provider: new GeminiProvider({
@@ -315,6 +323,8 @@ async function demonstrateSessionPersistence() {
       userName: "Alice",
       isVip: false,
     },
+    // NEW: Agent-level schema
+    schema: orderSchema,
     persistence: {
       adapter: new MemoryAdapter(),
       autoSave: true, // Automatic persistence
@@ -334,14 +344,14 @@ async function demonstrateSessionPersistence() {
 
   console.log("After first interaction:");
   console.log("🤖 Agent:", response1.message);
-  console.log("Session data:", JSON.stringify(persistentAgent.session.getData<OrderData>(), null, 2));
+  console.log("Session data:", JSON.stringify(persistentAgent.session.getData<UnifiedOrderData>(), null, 2));
   console.log("History length:", persistentAgent.session.getHistory().length);
   console.log("Session automatically saved to persistence ✓");
 
   // Simulate server restart - create new agent instance with same sessionId
   console.log("\n🔄 Simulating server restart - creating new agent instance...");
 
-  const restoredAgent = new Agent<OrderContext>({
+  const restoredAgent = new Agent<OrderContext, UnifiedOrderData>({
     name: "Order Assistant",
     provider: new GeminiProvider({
       apiKey: process.env.GEMINI_API_KEY!,
@@ -352,6 +362,8 @@ async function demonstrateSessionPersistence() {
       userName: "Alice",
       isVip: false,
     },
+    // NEW: Agent-level schema
+    schema: orderSchema,
     persistence: {
       adapter: new MemoryAdapter(), // Same adapter instance for demo
       autoSave: true,
@@ -367,14 +379,14 @@ async function demonstrateSessionPersistence() {
   console.log("Session automatically restored:");
   console.log("- Session ID:", restoredAgent.session.id);
   console.log("- History length:", restoredAgent.session.getHistory().length);
-  console.log("- Restored data:", JSON.stringify(restoredAgent.session.getData<OrderData>(), null, 2));
+  console.log("- Restored data:", JSON.stringify(restoredAgent.session.getData<UnifiedOrderData>(), null, 2));
 
   // Continue conversation seamlessly
   const response2 = await restoredAgent.chat("Actually, make it urgent delivery");
 
   console.log("\nAfter continuing with restored session:");
   console.log("🤖 Agent:", response2.message);
-  console.log("Session data:", JSON.stringify(restoredAgent.session.getData<OrderData>(), null, 2));
+  console.log("Session data:", JSON.stringify(restoredAgent.session.getData<UnifiedOrderData>(), null, 2));
   console.log("History length:", restoredAgent.session.getHistory().length);
   console.log("Session automatically saved again ✓");
 }