flowquery 1.0.15 → 1.0.17

package/misc/apps/RAG/src/components/AdaptiveCardRenderer.tsx

@@ -235,10 +235,16 @@ export class AdaptiveCardRenderer extends React.Component<AdaptiveCardRendererPr
         this.containerRef.current.innerHTML = '';
         
         try {
+            // Normalize the card to standard Adaptive Card format
+            let cardPayload = normalizeAdaptiveCard(card);
+            
+            if (!cardPayload) {
+                throw new Error('Invalid Adaptive Card format');
+            }
+            
             // Apply data binding if data is provided
-            let cardPayload = card;
             if (data) {
-                const template = new ACData.Template(card);
+                const template = new ACData.Template(cardPayload);
                 cardPayload = template.expand({
                     $root: data
                 });
@@ -299,14 +305,76 @@ export class AdaptiveCardRenderer extends React.Component<AdaptiveCardRendererPr
 }
 
 /**
- * Helper function to check if an object looks like an Adaptive Card
+ * Helper function to check if an object looks like an Adaptive Card.
+ * Supports both standard format (type: 'AdaptiveCard') and alternative format (cardType: 'AdaptiveCard').
  */
 export function isAdaptiveCard(obj: unknown): obj is Record<string, unknown> {
-    return (
-        typeof obj === 'object' &&
-        obj !== null &&
-        (obj as Record<string, unknown>).type === 'AdaptiveCard'
-    );
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    
+    const card = obj as Record<string, unknown>;
+    
+    // Standard Adaptive Card format
+    if (card.type === 'AdaptiveCard') {
+        return true;
+    }
+    
+    // Alternative format with cardType/cardBody
+    if (card.cardType === 'AdaptiveCard') {
+        return true;
+    }
+    
+    // Check if it's an array containing Adaptive Cards
+    if (Array.isArray(obj) && obj.length > 0) {
+        return obj.some(item => isAdaptiveCard(item));
+    }
+    
+    return false;
+}
+
+/**
+ * Normalizes a card payload to the standard Adaptive Card format.
+ * Handles:
+ * - Arrays of cards (returns the first card)
+ * - Alternative format with cardType/cardBody properties
+ * - Standard format (passed through unchanged)
+ */
+export function normalizeAdaptiveCard(obj: unknown): Record<string, unknown> | null {
+    if (typeof obj !== 'object' || obj === null) {
+        return null;
+    }
+    
+    // Handle arrays - extract the first valid card
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            const normalized = normalizeAdaptiveCard(item);
+            if (normalized) {
+                return normalized;
+            }
+        }
+        return null;
+    }
+    
+    const card = obj as Record<string, unknown>;
+    
+    // Standard format - return as-is
+    if (card.type === 'AdaptiveCard') {
+        return card;
+    }
+    
+    // Alternative format - convert to standard format
+    if (card.cardType === 'AdaptiveCard') {
+        return {
+            type: 'AdaptiveCard',
+            $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+            version: (card.version as string) || '1.5',
+            body: card.cardBody || card.body || [],
+            actions: card.actions || []
+        };
+    }
+    
+    return null;
 }
 
 export default AdaptiveCardRenderer;

package/misc/apps/RAG/src/components/index.ts

@@ -1,19 +1,28 @@
 // Chat components exports
-export { ChatContainer } from './ChatContainer';
-export { ChatMessage } from './ChatMessage';
-export { ChatInput } from './ChatInput';
-export { ApiKeySettings } from './ApiKeySettings';
+export { ChatContainer } from "./ChatContainer";
+export { ChatMessage } from "./ChatMessage";
+export { ChatInput } from "./ChatInput";
+export { ApiKeySettings } from "./ApiKeySettings";
 
 // FlowQuery Runner
-export { FlowQueryRunner } from './FlowQueryRunner';
+export { FlowQueryRunner } from "./FlowQueryRunner";
 
 // Adaptive Card Renderer
-export { AdaptiveCardRenderer, isAdaptiveCard } from './AdaptiveCardRenderer';
+export {
+    AdaptiveCardRenderer,
+    isAdaptiveCard,
+    normalizeAdaptiveCard,
+} from "./AdaptiveCardRenderer";
 
 // FlowQuery Agent
-export { processQuery, processQueryStream } from './FlowQueryAgent';
-export type { AgentStep, AgentResult, FlowQueryAgentOptions, AgentStreamCallback } from './FlowQueryAgent';
+export { processQuery, processQueryStream } from "./FlowQueryAgent";
+export type {
+    AgentStep,
+    AgentResult,
+    FlowQueryAgentOptions,
+    AgentStreamCallback,
+} from "./FlowQueryAgent";
 
 // Types
-export type { Message } from './ChatMessage';
-export type { AdaptiveCardRendererProps } from './AdaptiveCardRenderer';
+export type { Message } from "./ChatMessage";
+export type { AdaptiveCardRendererProps } from "./AdaptiveCardRenderer";

package/misc/apps/RAG/src/plugins/loaders/CatFacts.ts

@@ -1,42 +1,37 @@
 /**
  * Example plugin: Fetch random cat facts from the Cat Facts API.
- * 
+ *
  * Usage in FlowQuery:
- *   LOAD JSON FROM catFacts(5) AS fact
- *   RETURN fact.text
+ *   CALL catFacts(5) YIELD text, length
  */
+import { AsyncFunction, FunctionDef } from "flowquery/extensibility";
 
-import { FunctionDef, AsyncFunction } from 'flowquery/extensibility';
-
-const CAT_FACTS_API = 'https://catfact.ninja/facts';
+const CAT_FACTS_API = "https://catfact.ninja/facts";
 
 /**
  * CatFacts class - fetches random cat facts from the Cat Facts API.
  */
 @FunctionDef({
-    description: 'Fetches random cat facts from the Cat Facts API (catfact.ninja)',
-    category: 'async',
+    description: "Fetches random cat facts from the Cat Facts API (catfact.ninja)",
+    category: "async",
     parameters: [
         {
-            name: 'count',
-            description: 'Number of cat facts to fetch',
-            type: 'number',
+            name: "count",
+            description: "Number of cat facts to fetch",
+            type: "number",
             required: false,
-            default: 1
-        }
+            default: 1,
+        },
     ],
     output: {
-        description: 'Cat fact object',
-        type: 'object',
+        description: "Cat fact object",
+        type: "object",
         properties: {
-            text: { description: 'The cat fact text', type: 'string' },
-            length: { description: 'Length of the fact text', type: 'number' }
-        }
+            text: { description: "The cat fact text", type: "string" },
+            length: { description: "Length of the fact text", type: "number" },
+        },
     },
-    examples: [
-        "LOAD JSON FROM catFacts() AS fact RETURN fact.text",
-        "LOAD JSON FROM catFacts(5) AS fact RETURN fact.text, fact.length AS length"
-    ]
+    examples: ["CALL catFacts() YIELD text", "CALL catFacts(5) YIELD text, length"],
 })
 export class CatFacts extends AsyncFunction {
     private readonly apiUrl: string;
@@ -48,25 +43,25 @@ export class CatFacts extends AsyncFunction {
 
     /**
      * Fetches random cat facts from the Cat Facts API.
-     * 
+     *
      * @param count - Number of cat facts to fetch (default: 1)
      */
     async *generate(count: number = 1): AsyncGenerator<any, void, unknown> {
         const url = `${this.apiUrl}?limit=${count}`;
         const response = await fetch(url);
-        
+
         if (!response.ok) {
             throw new Error(`Failed to fetch cat facts: ${response.statusText}`);
         }
 
         const json = await response.json();
         const data = json.data || [];
-        
+
         for (const item of data) {
             // Map 'fact' to 'text' for backwards compatibility with existing queries
             yield {
                 text: item.fact,
-                length: item.length
+                length: item.length,
             };
         }
     }

package/misc/apps/RAG/src/plugins/loaders/FetchJson.ts

@@ -1,58 +1,57 @@
 /**
  * Example plugin: Fetch JSON data from a URL.
- * 
+ *
  * Usage in FlowQuery:
- *   LOAD JSON FROM fetchJson('https://api.example.com/data') AS item
- *   RETURN item.name, item.value
+ *   CALL fetchJson('https://api.example.com/data') YIELD name, value
  */
-
-import { FunctionDef, AsyncFunction } from 'flowquery/extensibility';
+import { AsyncFunction, FunctionDef } from "flowquery/extensibility";
 
 /**
  * FetchJson class - fetches JSON data from a URL and yields items.
  */
 @FunctionDef({
-    description: 'Fetches JSON data from a URL. If the response is an array, yields each item individually.',
-    category: 'async',
+    description:
+        "Fetches JSON data from a URL. If the response is an array, yields each item individually.",
+    category: "async",
     parameters: [
         {
-            name: 'url',
-            description: 'The URL to fetch JSON from',
-            type: 'string',
-            required: true
+            name: "url",
+            description: "The URL to fetch JSON from",
+            type: "string",
+            required: true,
         },
         {
-            name: 'options',
-            description: 'Optional fetch options (headers, method, etc.)',
-            type: 'object',
-            required: false
-        }
+            name: "options",
+            description: "Optional fetch options (headers, method, etc.)",
+            type: "object",
+            required: false,
+        },
     ],
     output: {
-        description: 'JSON data items',
-        type: 'object'
+        description: "JSON data items",
+        type: "object",
     },
     examples: [
-        "LOAD JSON FROM fetchJson('https://api.example.com/users') AS user RETURN user.name",
-        "LOAD JSON FROM fetchJson('https://api.example.com/data') AS item RETURN item WHERE item.active = true"
-    ]
+        "CALL fetchJson('https://api.example.com/users') YIELD name",
+        "CALL fetchJson('https://api.example.com/data') YIELD name, active WHERE active = true",
+    ],
 })
 export class FetchJson extends AsyncFunction {
     /**
      * Fetches JSON data from a URL and yields each item if array, or the object itself.
-     * 
+     *
      * @param url - The URL to fetch JSON from
      * @param options - Optional fetch options
      */
     async *generate(url: string, options?: RequestInit): AsyncGenerator<any, void, unknown> {
         const response = await fetch(url, options);
-        
+
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
 
         const data = await response.json();
-        
+
         if (Array.isArray(data)) {
             for (const item of data) {
                 yield item;
@@ -63,4 +62,4 @@ export class FetchJson extends AsyncFunction {
     }
 }
 
-export default FetchJson;
+export default FetchJson;