@falai/agent 0.8.1 → 0.9.0-alpha-2

package/examples/{streaming-agent.ts → advanced-patterns/streaming-responses.ts}

@@ -8,14 +8,10 @@
 
 import {
   Agent,
-  createMessageEvent,
-  EventSource,
   AnthropicProvider,
   OpenAIProvider,
   GeminiProvider,
-  createSession,
-  END_ROUTE,
-} from "../src/index";
+} from "../../src/index";
 
 // Custom context type
 interface ConversationContext {
@@ -40,7 +36,7 @@ async function streamingWithAnthropic() {
   });
 
   // Create agent
-  const agent = new Agent<ConversationContext>({
+  const agent = new Agent<ConversationContext, unknown>({
     name: "StreamingAssistant",
     description: "An AI assistant that streams responses in real-time",
     goal: "Provide helpful information with streaming responses",
@@ -62,23 +58,28 @@ async function streamingWithAnthropic() {
 
   // Create conversation history
   const history = [
-    createMessageEvent(
-      EventSource.CUSTOMER,
-      "User",
-      "Explain quantum computing in simple terms."
-    ),
+    {
+      role: "user" as const,
+      content: "Explain quantum computing in simple terms.",
+      name: "User",
+    },
   ];
 
   try {
     console.log("📤 Streaming response from Claude...\n");
     console.log("Response: ");
 
-    // Initialize session step for streaming conversation
-    let session = createSession();
+    // Session is automatically managed by the agent
+    console.log("✨ Session ready:", agent.session.id);
+
+    // Add user message to session history
+    await agent.session.addMessage("user", "What's the weather like today?");
 
-    // Use respondStream for real-time streaming with session step
+    // Use respondStream for real-time streaming with session history
     let fullMessage = "";
-    for await (const chunk of agent.respondStream({ history, session })) {
+    for await (const chunk of agent.respondStream({ 
+      history: agent.session.getHistory() 
+    })) {
       // chunk.delta contains the new text
       // chunk.accumulated contains the full text so far
       // chunk.done indicates if this is the final chunk
@@ -94,11 +95,13 @@ async function streamingWithAnthropic() {
         console.log(
           `   - Route: ${chunk.session?.currentRoute?.title || "None"}`
         );
-        console.log(`   - Data:`, chunk.session?.data || "None");
+        console.log(`   - Data:`, agent.session.getData() || "None");
         console.log(`   - Tool Calls: ${chunk.toolCalls?.length || 0}`);
 
-        // Update session with progress
-        session = chunk.session!;
+        console.log(`   - Full Message: ${fullMessage}`);
+        
+        // Add assistant response to session history
+        await agent.session.addMessage("assistant", fullMessage);
       }
     }
   } catch (error) {
@@ -117,7 +120,7 @@ async function streamingWithOpenAI() {
     },
   });
 
-  const agent = new Agent<ConversationContext>({
+  const agent = new Agent<ConversationContext, unknown>({
     name: "CreativeAssistant",
     description: "A creative AI assistant",
     context: {
@@ -131,21 +134,26 @@ async function streamingWithOpenAI() {
   });
 
   const history = [
-    createMessageEvent(
-      EventSource.CUSTOMER,
-      "User",
-      "Write a short poem about TypeScript"
-    ),
+    {
+      role: "user" as const,
+      content: "Write a short poem about TypeScript",
+      name: "User",
+    },
   ];
 
   try {
     console.log("📤 Streaming response from OpenAI...\n");
     console.log("Response: ");
 
-    // Initialize session step for streaming conversation
-    let session = createSession();
+    // Session is automatically managed by the agent
+    console.log("✨ Session ready:", agent.session.id);
 
-    for await (const chunk of agent.respondStream({ history, session })) {
+    // Add user message to session history
+    await agent.session.addMessage("user", "What's the weather like today?");
+
+    for await (const chunk of agent.respondStream({ 
+      history: agent.session.getHistory() 
+    })) {
       if (chunk.delta) {
         process.stdout.write(chunk.delta);
       }
@@ -155,10 +163,10 @@ async function streamingWithOpenAI() {
         console.log(
           `   - Route: ${chunk.session?.currentRoute?.title || "None"}`
         );
-        console.log(`   - Data:`, chunk.session?.data || "None");
+        console.log(`   - Data:`, agent.session.getData() || "None");
 
-        // Update session with progress
-        session = chunk.session!;
+        // Add assistant response to session history
+        await agent.session.addMessage("assistant", chunk.accumulated || "");
       }
     }
   } catch (error) {
@@ -171,13 +179,13 @@ async function streamingWithGemini() {
 
   const provider = new GeminiProvider({
     apiKey: process.env.GEMINI_API_KEY || "",
-    model: "models/gemini-2.0-flash-exp",
+    model: "models/gemini-2.5-flash",
     config: {
       temperature: 0.7,
     },
   });
 
-  const agent = new Agent<ConversationContext>({
+  const agent = new Agent<ConversationContext, unknown>({
     name: "AnalyticalAssistant",
     description: "An analytical AI assistant",
     context: {
@@ -191,21 +199,26 @@ async function streamingWithGemini() {
   });
 
   const history = [
-    createMessageEvent(
-      EventSource.CUSTOMER,
-      "User",
-      "What are the key differences between REST and GraphQL?"
-    ),
+    {
+      role: "user" as const,
+      content: "What are the key differences between REST and GraphQL?",
+      name: "User",
+    },
   ];
 
   try {
     console.log("📤 Streaming response from Gemini...\n");
     console.log("Response: ");
 
-    // Initialize session step for streaming conversation
-    let session = createSession();
+    // Session is automatically managed by the agent
+    console.log("✨ Session ready:", agent.session.id);
 
-    for await (const chunk of agent.respondStream({ history, session })) {
+    // Add user message to session history
+    await agent.session.addMessage("user", "What are the key differences between REST and GraphQL?");
+
+    for await (const chunk of agent.respondStream({ 
+      history: agent.session.getHistory() 
+    })) {
       if (chunk.delta) {
         process.stdout.write(chunk.delta);
       }
@@ -215,10 +228,10 @@ async function streamingWithGemini() {
         console.log(
           `   - Route: ${chunk.session?.currentRoute?.title || "None"}`
         );
-        console.log(`   - Data:`, chunk.session?.data || "None");
+        console.log(`   - Data:`, agent.session.getData() || "None");
 
-        // Update session with progress
-        session = chunk.session!;
+        // Add assistant response to session history
+        await agent.session.addMessage("assistant", chunk.accumulated || "");
       }
     }
   } catch (error) {
@@ -234,7 +247,22 @@ async function streamingWithRoutes() {
     model: "claude-sonnet-4-5",
   });
 
-  const agent = new Agent<ConversationContext>({
+  // Define feedback data schema
+  interface FeedbackData {
+    rating: number;
+    comments: string;
+  }
+
+  const feedbackSchema = {
+    type: "object",
+    properties: {
+      rating: { type: "number", minimum: 1, maximum: 5 },
+      comments: { type: "string" },
+    },
+    required: ["rating"],
+  };
+
+  const agent = new Agent<ConversationContext, FeedbackData>({
     name: "SupportAgent",
     description: "A customer support agent with conversation routes",
     context: {
@@ -245,6 +273,8 @@ async function streamingWithRoutes() {
       },
     },
     provider: provider,
+    // NEW: Agent-level schema
+    schema: feedbackSchema,
   });
 
   // Create a route
@@ -255,56 +285,54 @@ async function streamingWithRoutes() {
   });
 
   supportRoute.initialStep.nextStep({
-    instructions: "Understand the user's product question",
+    prompt: "Understand the user's product question",
   });
 
   // Create a feedback route
-  const feedbackRoute = agent.createRoute<{
-    rating: number;
-    comments: string;
-  }>({
+  agent.createRoute({
     title: "Collect Feedback",
     description: "Collect user feedback on their support experience",
     conditions: ["User wants to provide feedback"],
-    schema: {
-      type: "object",
-      properties: {
-        rating: { type: "number", minimum: 1, maximum: 5 },
-        comments: { type: "string" },
-      },
-      required: ["rating"],
-    },
+    // NEW: Required fields for route completion
+    requiredFields: ["rating"],
+    // NEW: Optional fields
+    optionalFields: ["comments"],
     steps: [
       {
-        instructions: "How would you rate your support experience from 1 to 5?",
+        prompt: "How would you rate your support experience from 1 to 5?",
         collect: ["rating"],
       },
       {
-        instructions: "Thanks for the rating! Any other comments?",
+        prompt: "Thanks for the rating! Any other comments?",
         collect: ["comments"],
       },
       {
-        instructions: "We appreciate your feedback!",
+        prompt: "We appreciate your feedback!",
       },
     ],
   });
 
   const history = [
-    createMessageEvent(
-      EventSource.CUSTOMER,
-      "User",
-      "How do I reset my password?"
-    ),
+    {
+      role: "user" as const,
+      content: "How do I reset my password?",
+      name: "User",
+    },
   ];
 
   try {
     console.log("📤 Streaming response with route detection...\n");
     console.log("Response: ");
 
-    // Initialize session step for streaming conversation
-    let session = createSession();
+    // Session is automatically managed by the agent
+    console.log("✨ Session ready:", agent.session.id);
+
+    // Add user message to session history
+    await agent.session.addMessage("user", "How do I reset my password?");
 
-    for await (const chunk of agent.respondStream({ history, session })) {
+    for await (const chunk of agent.respondStream({ 
+      history: agent.session.getHistory() 
+    })) {
       if (chunk.delta) {
         process.stdout.write(chunk.delta);
       }
@@ -315,23 +343,17 @@ async function streamingWithRoutes() {
         console.log(
           `   - Route: ${chunk.session?.currentRoute?.title || "None"}`
         );
-        console.log(`   - Data:`, chunk.session?.data || "None");
+        console.log(`   - Data:`, agent.session.getData() || "None");
 
         // Check for route completion
         if (chunk.isRouteComplete) {
           console.log("\n✅ Route complete!");
           if (chunk.session?.currentRoute?.title === "Collect Feedback") {
-            await logFeedback(
-              agent.getData(chunk.session?.id) as {
-                rating: number;
-                comments: string;
-              }
-            );
+            await logFeedback(agent.session.getData() as FeedbackData);
           }
         }
 
-        // Update session with progress
-        session = chunk.session!;
+        // Session is automatically updated by the agent
       }
     }
   } catch (error) {
@@ -347,7 +369,7 @@ async function streamingWithAbortSignal() {
     model: "claude-sonnet-4-5",
   });
 
-  const agent = new Agent<ConversationContext>({
+  const agent = new Agent<ConversationContext, unknown>({
     name: "Assistant",
     description: "An assistant that can be interrupted",
     context: {
@@ -361,11 +383,11 @@ async function streamingWithAbortSignal() {
   });
 
   const history = [
-    createMessageEvent(
-      EventSource.CUSTOMER,
-      "User",
-      "Tell me a very long story about space exploration."
-    ),
+    {
+      role: "user" as const,
+      content: "Tell me a very long story about space exploration.",
+      name: "User",
+    },
   ];
 
   // Create an AbortController to cancel the stream
@@ -381,12 +403,14 @@ async function streamingWithAbortSignal() {
     console.log("📤 Streaming response (will abort after 3s)...\n");
     console.log("Response: ");
 
-    // Initialize session step for streaming conversation
-    let session = createSession();
+    // Session is automatically managed by the agent
+    console.log("✨ Session ready:", agent.session.id);
+
+    // Add user message to session history
+    await agent.session.addMessage("user", "Tell me a very long story about space exploration.");
 
     for await (const chunk of agent.respondStream({
-      history,
-      session,
+      history: agent.session.getHistory(),
       signal: abortController.signal,
     })) {
       if (chunk.delta) {
@@ -399,10 +423,12 @@ async function streamingWithAbortSignal() {
         console.log(
           `   - Route: ${chunk.session?.currentRoute?.title || "None"}`
         );
-        console.log(`   - Data:`, chunk.session?.data || "None");
+        console.log(`   - Data:`, agent.session.getData() || "None");
+
+        // Add assistant response to session history
+        await agent.session.addMessage("assistant", chunk.accumulated || "");
 
-        // Update session with progress
-        session = chunk.session!;
+        // Session is automatically updated by the agent
 
         clearTimeout(timeout);
       }