totem-llm 0.1.0

package/server/utils/agents/aibitat/plugins/create-files/pptx/create-presentation.js

@@ -0,0 +1,342 @@
+const createFilesLib = require("../lib.js");
+const { getTheme, getAvailableThemes } = require("./themes.js");
+const {
+  renderTitleSlide,
+  renderSectionSlide,
+  renderContentSlide,
+  renderBlankSlide,
+} = require("./utils.js");
+const { runSectionAgent } = require("./section-agent.js");
+
+/**
+ * Extracts recent conversation history from the parent AIbitat's chat log
+ * to provide context to each section sub-agent.
+ * @param {Array} chats - The parent AIbitat's _chats array
+ * @param {number} [maxMessages=10] - Maximum messages to include
+ * @returns {string} Formatted conversation context
+ */
+function extractConversationContext(chats, maxMessages = 10) {
+  if (!Array.isArray(chats) || chats.length === 0) return "";
+
+  const recent = chats
+    .filter((c) => c.state === "success" && c.content)
+    .slice(-maxMessages);
+
+  if (recent.length === 0) return "";
+
+  return recent
+    .map((c) => {
+      const content =
+        typeof c.content === "string" ? c.content.substring(0, 500) : "";
+      return `${c.from}: ${content}`;
+    })
+    .join("\n");
+}
+
+module.exports.CreatePptxPresentation = {
+  name: "create-pptx-presentation",
+  plugin: function () {
+    return {
+      name: "create-pptx-presentation",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Create a professional PowerPoint presentation (PPTX). " +
+            "Provide a title, theme, and section outlines with key points. " +
+            "Each section is independently researched and built by a focused sub-agent " +
+            "that can use web search and web scraping to gather data.",
+          examples: [
+            {
+              prompt: "Create a presentation about project updates",
+              call: JSON.stringify({
+                filename: "project-updates.pptx",
+                title: "Q1 Project Updates",
+                theme: "corporate",
+                sections: [
+                  {
+                    title: "Overview",
+                    keyPoints: [
+                      "Project on track for Q1 delivery",
+                      "Team expanded by 2 new members",
+                      "Budget within expectations",
+                    ],
+                  },
+                  {
+                    title: "Key Achievements",
+                    keyPoints: [
+                      "Launched new feature X",
+                      "Reduced bug count by 40%",
+                      "Improved performance by 25%",
+                    ],
+                    instructions:
+                      "Include specific metrics and quarter-over-quarter comparisons",
+                  },
+                ],
+              }),
+            },
+            {
+              prompt: "Create a dark themed presentation about AI trends",
+              call: JSON.stringify({
+                filename: "ai-trends.pptx",
+                title: "AI Trends 2025",
+                theme: "dark",
+                sections: [
+                  {
+                    title: "Large Language Models",
+                    keyPoints: [
+                      "Model scaling trends",
+                      "Open vs closed source landscape",
+                    ],
+                    instructions:
+                      "Research the latest developments and include recent data",
+                  },
+                  {
+                    title: "AI in Enterprise",
+                    keyPoints: ["Adoption rates", "Top use cases", "ROI data"],
+                  },
+                ],
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              filename: {
+                type: "string",
+                description:
+                  "The filename for the presentation (should end with .pptx).",
+              },
+              title: {
+                type: "string",
+                description:
+                  "The title of the presentation (shown on title slide).",
+              },
+              author: {
+                type: "string",
+                description:
+                  "Optional author name for the presentation metadata.",
+              },
+              theme: {
+                type: "string",
+                enum: getAvailableThemes(),
+                description:
+                  "Color theme for the presentation. Options: " +
+                  getAvailableThemes().join(", "),
+              },
+              sections: {
+                type: "array",
+                description:
+                  "Section outlines for the presentation. Each section is independently researched and built by a focused sub-agent.",
+                items: {
+                  type: "object",
+                  properties: {
+                    title: {
+                      type: "string",
+                      description: "The section title.",
+                    },
+                    keyPoints: {
+                      type: "array",
+                      items: { type: "string" },
+                      description:
+                        "Key points this section should cover. The sub-agent will expand these into detailed slides.",
+                    },
+                    instructions: {
+                      type: "string",
+                      description:
+                        "Optional guidance for the section builder (e.g. 'research recent statistics', 'compare with competitors', 'include a data table').",
+                    },
+                  },
+                  required: ["title"],
+                },
+              },
+            },
+            required: ["filename", "title", "sections"],
+            additionalProperties: false,
+          },
+
+          handler: async function ({
+            filename = "presentation.pptx",
+            title = "Untitled Presentation",
+            author = "",
+            theme: themeName = "default",
+            sections = [],
+          }) {
+            try {
+              this.super.handlerProps.log(
+                `Using the create-pptx-presentation tool.`
+              );
+
+              if (!filename.toLowerCase().endsWith(".pptx"))
+                filename += ".pptx";
+
+              const theme = getTheme(themeName);
+              const totalSections = sections.length;
+
+              this.super.introspect(
+                `${this.caller}: Planning presentation "${title}" — ${totalSections} section${totalSections !== 1 ? "s" : ""}, ${theme.name} theme`
+              );
+
+              // Ask for approval BEFORE kicking off the expensive sub-agent work
+              if (this.super.requestToolApproval) {
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: {
+                    filename,
+                    title,
+                    sectionCount: totalSections,
+                    sectionTitles: sections.map((s) => s.title),
+                  },
+                  description: `Create PowerPoint presentation "${title}" with ${totalSections} sections`,
+                });
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              const conversationContext = extractConversationContext(
+                this.super._chats
+              );
+
+              // Run a focused sub-agent for each section sequentially.
+              // Sequential execution is intentional — local models typically serve
+              // one request at a time, and it keeps introspection events ordered.
+              const allSlides = [];
+              const allCitations = [];
+              for (let i = 0; i < sections.length; i++) {
+                const section = sections[i];
+                this.super.introspect(
+                  `${this.caller}: [${i + 1}/${totalSections}] Building section "${section.title}"…`
+                );
+
+                const sectionResult = await runSectionAgent({
+                  parentAibitat: this.super,
+                  section,
+                  presentationTitle: title,
+                  conversationContext,
+                  sectionPrefix: `${i + 1}/${totalSections}`,
+                });
+
+                const slideCount = sectionResult.slides?.length || 0;
+                allSlides.push(...(sectionResult.slides || []));
+                if (sectionResult.citations?.length > 0)
+                  allCitations.push(...sectionResult.citations);
+
+                this.super.introspect(
+                  `${this.caller}: [${i + 1}/${totalSections}] Section "${section.title}" complete — ${slideCount} slide${slideCount !== 1 ? "s" : ""}`
+                );
+              }
+
+              // Roll up all citations from sub-agents to the parent so they
+              // appear as sources on the final assistant message.
+              if (allCitations.length > 0) this.super.addCitation(allCitations);
+
+              // Assemble the final PPTX from all section outputs
+              this.super.introspect(
+                `${this.caller}: Assembling final deck — ${allSlides.length} slides total`
+              );
+
+              const PptxGenJS = require("pptxgenjs");
+              const pptx = new PptxGenJS();
+
+              pptx.title = title;
+              if (author) pptx.author = author;
+              pptx.company = "AnythingLLM";
+
+              const totalSlideCount = allSlides.length;
+
+              // Title slide
+              const titleSlide = pptx.addSlide();
+              renderTitleSlide(titleSlide, pptx, { title, author }, theme);
+
+              // Render every slide produced by the section agents
+              allSlides.forEach((slideData, index) => {
+                const slide = pptx.addSlide();
+                const slideNumber = index + 1;
+                const layout = slideData.layout || "content";
+
+                switch (layout) {
+                  case "title":
+                  case "section":
+                    renderSectionSlide(
+                      slide,
+                      pptx,
+                      slideData,
+                      theme,
+                      slideNumber,
+                      totalSlideCount
+                    );
+                    break;
+                  case "blank":
+                    renderBlankSlide(
+                      slide,
+                      pptx,
+                      theme,
+                      slideNumber,
+                      totalSlideCount
+                    );
+                    break;
+                  default:
+                    renderContentSlide(
+                      slide,
+                      pptx,
+                      slideData,
+                      theme,
+                      slideNumber,
+                      totalSlideCount
+                    );
+                    break;
+                }
+              });
+
+              const buffer = await pptx.write({ outputType: "nodebuffer" });
+              const bufferSizeKB = (buffer.length / 1024).toFixed(2);
+              const bufferSizeMB = (buffer.length / (1024 * 1024)).toFixed(2);
+              this.super.handlerProps.log(
+                `create-pptx-presentation: Generated buffer - size: ${bufferSizeKB}KB (${bufferSizeMB}MB), slides: ${totalSlideCount}, theme: ${theme.name}`
+              );
+
+              const displayFilename = filename.split("/").pop();
+
+              const savedFile = await createFilesLib.saveGeneratedFile({
+                fileType: "pptx",
+                extension: "pptx",
+                buffer,
+                displayFilename,
+              });
+
+              this.super.socket.send("fileDownloadCard", {
+                filename: savedFile.displayFilename,
+                storageFilename: savedFile.filename,
+                fileSize: savedFile.fileSize,
+              });
+
+              createFilesLib.registerOutput(this.super, "PptxFileDownload", {
+                filename: savedFile.displayFilename,
+                storageFilename: savedFile.filename,
+                fileSize: savedFile.fileSize,
+              });
+
+              this.super.introspect(
+                `${this.caller}: Successfully created presentation "${title}"`
+              );
+
+              return `Successfully created presentation "${title}" with ${totalSlideCount} slides across ${totalSections} sections using the ${theme.name} theme.`;
+            } catch (e) {
+              this.super.handlerProps.log(
+                `create-pptx-presentation error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error creating presentation: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/create-files/pptx/section-agent.js

@@ -0,0 +1,257 @@
+const AIbitat = require("../../../index.js");
+
+const SECTION_BUILDER_PROMPT = `You are a focused presentation section builder. Your ONLY task is to create detailed slides for ONE section of a PowerPoint presentation.
+
+You have access to web search and web scraping tools, but only use them when the topic genuinely requires up-to-date information you don't already know (e.g., current statistics, recent events, specific company data). For general knowledge topics, create slides directly from your existing knowledge.
+
+RULES:
+- Create 2-5 slides for this section (no more)
+- Each content slide should have 3-6 concise bullet points
+- Be specific and data-driven when possible
+- Include speaker notes with key talking points
+- Do NOT add a title slide - only section content
+
+When finished, you MUST call the submit-section-slides tool with your slides. Do not respond with raw JSON - always use the tool.
+
+Available slide layouts:
+- "section": Divider slide with title + optional subtitle
+- "content": Bullet points with title + content array + optional notes
+  - May include "table": { "headers": ["Col1", "Col2"], "rows": [["a", "b"]] }
+- "blank": Empty slide`;
+
+/**
+ * Spawns a focused child AIbitat agent to build slides for a single presentation section.
+ * The child reuses the parent's provider/model/socket so introspection events (tool calls,
+ * research progress) flow to the frontend in real-time.
+ *
+ * @param {Object} options
+ * @param {AIbitat} options.parentAibitat - The parent AIbitat instance (provides provider, socket, introspect)
+ * @param {Object} options.section - Section definition { title, keyPoints?, instructions? }
+ * @param {string} options.presentationTitle - Overall presentation title for context
+ * @param {string} [options.conversationContext] - Recent conversation history for context
+ * @param {string} [options.sectionPrefix] - Progress indicator like "1/5" for UI display
+ * @returns {Promise<{slides: Object[], citations: Object[]}>} Parsed section slides and accumulated citations
+ */
+async function runSectionAgent({
+  parentAibitat,
+  section,
+  presentationTitle,
+  conversationContext = "",
+  sectionPrefix = "",
+}) {
+  const log = parentAibitat.handlerProps?.log || console.log;
+
+  const childAibitat = new AIbitat({
+    provider: parentAibitat.defaultProvider.provider,
+    model: parentAibitat.defaultProvider.model,
+    chats: [],
+    handlerProps: parentAibitat.handlerProps,
+    maxToolCalls: 5,
+  });
+
+  // Share introspect so tool activity (web-search status, etc.) streams to the frontend
+  childAibitat.introspect = parentAibitat.introspect;
+
+  // Filtered socket: pass through introspection but suppress reportStreamEvent
+  // so sub-agent chatter doesn't render in the UI as a chat message.
+  childAibitat.socket = {
+    send: (type, content) => {
+      if (type === "reportStreamEvent") return;
+      parentAibitat.socket?.send(type, content);
+    },
+  };
+
+  // Only load the research tools this sub-agent needs
+  const { webBrowsing } = require("../../web-browsing.js");
+  const { webScraping } = require("../../web-scraping.js");
+  childAibitat.use(webBrowsing.plugin());
+  childAibitat.use(webScraping.plugin());
+
+  // Internal tool for structured slide submission - not exposed as a public plugin
+  childAibitat.function({
+    super: childAibitat,
+    name: "submit-section-slides",
+    description:
+      "Submit the completed slides for this presentation section. Call this tool when you have finished creating all slides.",
+    parameters: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: {
+        slides: {
+          type: "array",
+          description: "Array of slide objects for this section",
+          items: {
+            type: "object",
+            properties: {
+              layout: {
+                type: "string",
+                enum: ["section", "content", "blank"],
+                description: "The slide layout type",
+              },
+              title: {
+                type: "string",
+                description: "The slide title",
+              },
+              subtitle: {
+                type: "string",
+                description: "Optional subtitle (for section layout)",
+              },
+              content: {
+                type: "array",
+                items: { type: "string" },
+                description: "Bullet points (for content layout)",
+              },
+              notes: {
+                type: "string",
+                description: "Speaker notes for this slide",
+              },
+              table: {
+                type: "object",
+                description: "Optional table data",
+                properties: {
+                  headers: {
+                    type: "array",
+                    items: { type: "string" },
+                  },
+                  rows: {
+                    type: "array",
+                    items: {
+                      type: "array",
+                      items: { type: "string" },
+                    },
+                  },
+                },
+              },
+            },
+            required: ["layout", "title"],
+          },
+        },
+      },
+      required: ["slides"],
+      additionalProperties: false,
+    },
+    handler: function ({ slides }) {
+      this.super._submittedSlides = slides;
+      return "Slides submitted successfully. Section complete.";
+    },
+  });
+
+  const functions = Array.from(childAibitat.functions.values());
+  const messages = [
+    { role: "system", content: SECTION_BUILDER_PROMPT },
+    {
+      role: "user",
+      content: buildSectionPrompt({
+        section,
+        presentationTitle,
+        conversationContext,
+      }),
+    },
+  ];
+
+  const provider = childAibitat.getProviderForConfig(
+    childAibitat.defaultProvider
+  );
+  provider.attachHandlerProps(childAibitat.handlerProps);
+
+  log(
+    `[SectionAgent] Running sub-agent for section: "${section.title}" with ${functions.length} tools`
+  );
+
+  let agentName = `@section-builder`;
+  if (sectionPrefix) agentName = `[${sectionPrefix}] ${agentName}`;
+  try {
+    if (provider.supportsAgentStreaming) {
+      await childAibitat.handleAsyncExecution(
+        provider,
+        messages,
+        functions,
+        agentName
+      );
+    } else {
+      await childAibitat.handleExecution(
+        provider,
+        messages,
+        functions,
+        agentName
+      );
+    }
+  } catch (error) {
+    log(`[SectionAgent] Error in section "${section.title}": ${error.message}`);
+    return { ...buildFallbackSlides(section), citations: [] };
+  }
+
+  // Collect any citations the child accumulated (from web-search, web-scrape, etc.)
+  const citations = childAibitat._pendingCitations || [];
+
+  // Retrieve slides from the tool call (structured data, no parsing needed)
+  const slides = childAibitat._submittedSlides;
+  if (!Array.isArray(slides) || slides.length === 0) {
+    log(
+      `[SectionAgent] No slides submitted for "${section.title}", using fallback`
+    );
+    return { ...buildFallbackSlides(section), citations };
+  }
+
+  log(
+    `[SectionAgent] Section "${section.title}" produced ${slides.length} slides, ${citations.length} citations`
+  );
+  return { slides, citations };
+}
+
+function buildSectionPrompt({
+  section,
+  presentationTitle,
+  conversationContext,
+}) {
+  const parts = [
+    `Build slides for this section of the presentation "${presentationTitle}":`,
+    `\nSection Title: ${section.title}`,
+  ];
+
+  if (section.keyPoints?.length > 0) {
+    parts.push(
+      `\nKey Points to Cover:\n${section.keyPoints.map((p) => `- ${p}`).join("\n")}`
+    );
+  }
+
+  if (section.instructions) {
+    parts.push(`\nSpecial Instructions: ${section.instructions}`);
+  }
+
+  if (conversationContext) {
+    parts.push(`\nContext from the conversation:\n${conversationContext}`);
+  }
+
+  parts.push(
+    `\nCreate 2-5 detailed slides and submit them using the submit-section-slides tool. Only use web search/scraping if you genuinely lack the information needed.`
+  );
+
+  return parts.join("\n");
+}
+
+/**
+ * Generates basic slides from the section definition when the sub-agent fails.
+ */
+function buildFallbackSlides(section) {
+  const slides = [
+    {
+      layout: "section",
+      title: section.title,
+      subtitle: section.subtitle || "",
+    },
+  ];
+
+  if (section.keyPoints?.length > 0) {
+    slides.push({
+      layout: "content",
+      title: section.title,
+      content: section.keyPoints,
+      notes: `Key points for ${section.title}`,
+    });
+  }
+
+  return { slides };
+}
+
+module.exports = { runSectionAgent };