@photon-ai/flux 0.6.3 → 0.6.6

package/README.md

@@ -249,6 +249,37 @@ The `splitIntoMessages` helper function splits messages using `\n` and then loop
 
 For example, `"Hello!\nHow are you?\nNice to meet you!"` will be sent as three separate message bubbles. 
 
+## Tapbacks
+
+Agents can send tapback reactions (love, like, dislike, laugh, emphasize, question). When your agent receives a message, it can react to it using the `sendTapback` function. 
+
+To use `sendTapback`, you need to: 
+1. Capture `sendTapback` in `onInit` once at startup
+2. Call it in `invoke` when processing messages
+
+```
+import { FluxAgent, SendTapbackFn } from '@photon-ai/flux';
+
+let sendTapback: SendTapbackFn | undefined;
+
+const agent: FluxAgent = {
+  onInit: async (_sendMessage, _sendTapback) => {
+    sendTapback = _sendTapback;  // Save it for later
+  },
+
+  invoke: async ({ message, userPhoneNumber, messageGuid }) => {
+    // Now you can use it
+    if (sendTapback && messageGuid) {
+      await sendTapback(messageGuid, 'love', userPhoneNumber);
+    }
+
+    return "Hello!";
+  },
+};
+
+export default agent;
+```
+
 ## 💡 Examples
 
 ### Weather Agent
@@ -313,6 +344,56 @@ export default {
 };
 ```
 
+### Chatbot with Tapbacks
+
+A conversational chatbot with tapback functionalities: 
+
+```
+import "dotenv/config";
+import OpenAI from "openai";
+
+const openai = new OpenAI();
+const conversations = new Map<string, Array<{ role: "user" | "assistant" | "system"; content: string }>>();
+
+let sendTapback: ((messageGuid: string, reaction: string, userPhoneNumber: string) => Promise<boolean>) | undefined;
+
+export default {
+  onInit: async (_sendMessage: any, _sendTapback: any) => {
+    sendTapback = _sendTapback;
+  },
+
+  invoke: async ({ message, userPhoneNumber, messageGuid }: { message: string; userPhoneNumber: string; messageGuid?: string }) => {
+    // Get or create conversation history
+    if (!conversations.has(userPhoneNumber)) {
+      conversations.set(userPhoneNumber, [{
+        role: "system",
+        content: "You are a friendly iMessage assistant. Keep responses concise. For positive messages, start with [TAPBACK:love], [TAPBACK:laugh], or [TAPBACK:like]."
+      }]);
+    }
+    const history = conversations.get(userPhoneNumber)!;
+    history.push({ role: "user", content: message });
+
+    // Call OpenAI
+    const completion = await openai.chat.completions.create({
+      model: "gpt-4o-mini",
+      messages: history,
+    });
+
+    let response = completion.choices[0]?.message?.content || "Hello!";
+
+    // Extract and send tapback if present
+    const tapbackMatch = response.match(/^\[TAPBACK:(love|like|laugh|emphasize)\]/i);
+    if (tapbackMatch && sendTapback && messageGuid) {
+      await sendTapback(messageGuid, tapbackMatch[1].toLowerCase(), userPhoneNumber);
+      response = response.replace(tapbackMatch[0], "").trim();
+    }
+
+    history.push({ role: "assistant", content: response });
+    return response;
+  },
+};
+```
+
 ##  Why Flux?
 
 Connecting agents to messaging platforms traditionally involves complex processes like setting up servers, configuring webhooks, and dealing with platform APIs. Most solutions rely on SMS or WhatsApp, which can be unintuitive for many users.

package/dist/index.js

@@ -52185,26 +52185,20 @@ var FluxClient = class {
     }
     return result.success;
   }
-  async sendTapback(messageGuid, reaction) {
+  async sendTapback(messageGuid, reaction, chat) {
     if (!this.client) throw new Error("Not connected. Call connect() first.");
-    const payload = { messageGuid, reaction };
-    console.log(`[FLUX DEBUG] sendTapback called`);
-    console.log(`[FLUX DEBUG] Payload: ${JSON.stringify(payload)}`);
-    console.log(`[FLUX DEBUG] Payload keys: ${Object.keys(payload).join(", ")}`);
-    console.log(`[FLUX DEBUG] Server: ${GRPC_SERVER_ADDRESS}`);
     try {
-      console.log(`[FLUX DEBUG] Calling client.FluxService.sendTapback...`);
-      const result = await this.client.FluxService.sendTapback(payload);
-      console.log(`[FLUX DEBUG] Result: ${JSON.stringify(result)}`);
-      if (result.success) {
-        console.log(`[FLUX] Tapback sent successfully!`);
-      } else {
+      const result = await this.client.FluxService.sendTapback({
+        messageGuid,
+        reaction,
+        chat
+      });
+      if (!result.success) {
         console.error(`[FLUX] Tapback failed: ${result.error}`);
       }
       return result.success;
     } catch (error) {
-      console.error(`[FLUX DEBUG] Exception caught: ${error.message}`);
-      console.error(`[FLUX DEBUG] Error stack: ${error.stack}`);
+      console.error(`[FLUX] Tapback error: ${error.message}`);
       return false;
     }
   }
@@ -52422,6 +52416,37 @@ async function loadAgent(agentPath) {
   return agent;
 }
 
+// src/memory.ts
+var Memory = class {
+  store = /* @__PURE__ */ new Map();
+  // Add a message to a conversation
+  add(phoneNumber, message) {
+    const normalized = this.normalizePhone(phoneNumber);
+    if (!this.store.has(normalized)) {
+      this.store.set(normalized, []);
+    }
+    this.store.get(normalized).push(message);
+  }
+  // Get all messages for a conversation
+  get(phoneNumber) {
+    const normalized = this.normalizePhone(phoneNumber);
+    return this.store.get(normalized) || [];
+  }
+  // Clear history for a specific conversation, or all if no phone provided
+  clear(phoneNumber) {
+    if (phoneNumber) {
+      this.store.delete(this.normalizePhone(phoneNumber));
+    } else {
+      this.store.clear();
+    }
+  }
+  // Normalize phone number format
+  normalizePhone(phone) {
+    return phone.replace(/[\s\-\(\)]/g, "");
+  }
+};
+var memory = new Memory();
+
 // src/index.ts
 function splitIntoMessages2(response) {
   if (!response.includes("\n")) {
@@ -52469,17 +52494,29 @@ async function runLocal() {
     input: process.stdin,
     output: process.stdout
   });
+  const localPhoneNumber = "+1234567890";
   const askQuestion = () => {
     rl.question("You: ", async (input) => {
       if (!input.trim()) {
         askQuestion();
         return;
       }
+      memory.add(localPhoneNumber, {
+        role: "user",
+        content: input,
+        timestamp: Date.now()
+      });
       console.log("[FLUX] Thinking...");
       try {
         const response = await agent.invoke({
           message: input,
-          userPhoneNumber: "+1234567890"
+          userPhoneNumber: localPhoneNumber,
+          history: memory.get(localPhoneNumber)
+        });
+        memory.add(localPhoneNumber, {
+          role: "assistant",
+          content: response,
+          timestamp: Date.now()
         });
         const messages = splitIntoMessages2(response);
         for (const msg of messages) {
@@ -52523,12 +52560,24 @@ async function runProd() {
   console.log("[FLUX] Agent loaded successfully!");
   const flux = new FluxClient(phoneNumber, token, async (message) => {
     console.log(`[FLUX] Processing message from ${message.userPhoneNumber}: ${message.text}`);
+    memory.add(message.userPhoneNumber, {
+      role: "user",
+      content: message.text,
+      timestamp: Date.now(),
+      imageBase64: message.imageBase64
+    });
     try {
       const response = await agent.invoke({
         message: message.text,
         userPhoneNumber: message.userPhoneNumber,
         messageGuid: message.messageGuid,
-        imageBase64: message.imageBase64
+        imageBase64: message.imageBase64,
+        history: memory.get(message.userPhoneNumber)
+      });
+      memory.add(message.userPhoneNumber, {
+        role: "assistant",
+        content: response,
+        timestamp: Date.now()
       });
       console.log(`[FLUX] Agent response: ${response}`);
       return response;
@@ -52550,8 +52599,8 @@ async function runProd() {
         }
         return true;
       },
-      async (messageGuid, reaction) => {
-        return flux.sendTapback(messageGuid, reaction);
+      async (messageGuid, reaction, chat) => {
+        return flux.sendTapback(messageGuid, reaction, chat);
       }
     );
   }