@particle-academy/agent-integrations 0.6.1 → 0.6.3

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var react = require('react');
+var fancySlides = require('@particle-academy/fancy-slides');
 var jsxRuntime = require('react/jsx-runtime');
 
 var __defProp = Object.defineProperty;
@@ -1463,6 +1464,381 @@ function registerScreensBridge(host, options) {
     }
   };
 }
+var DEFAULT_AGENT7 = { id: "agent", name: "Agent", color: "#a855f7" };
+function registerSlidesBridge(host, options) {
+  const { adapter } = options;
+  const agent = { ...DEFAULT_AGENT7, ...options.agent ?? {} };
+  const disposers = [];
+  const deckTarget = () => ({
+    kind: "deck",
+    screenId: adapter.screenId,
+    elementId: adapter.getDeck().id,
+    label: adapter.getDeck().title
+  });
+  const slideTarget = (slideId) => ({
+    kind: "slide",
+    screenId: adapter.screenId,
+    elementId: slideId,
+    label: `slide:${slideId}`
+  });
+  const elementTarget = (slideId, elementId) => ({
+    kind: "slide-element",
+    screenId: adapter.screenId,
+    elementId,
+    label: `${slideId}/${elementId}`
+  });
+  const reg = (name, description, properties, required, handler, isMutation, resolveTarget) => {
+    const wrapped = (async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    });
+    const final = isMutation && resolveTarget ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent,
+      kind: "deck",
+      screenId: adapter.screenId,
+      resolveTarget: (ctx) => resolveTarget(ctx.args)
+    }) : wrapped;
+    disposers.push(
+      host.registerTool(
+        {
+          name,
+          description,
+          inputSchema: {
+            type: "object",
+            properties,
+            required,
+            additionalProperties: false
+          }
+        },
+        final
+      )
+    );
+  };
+  reg(
+    "deck_describe",
+    "Summary of the active deck \u2014 title, slide count, theme name, element-type counts.",
+    {},
+    [],
+    () => {
+      const deck = adapter.getDeck();
+      const elementCounts = {};
+      for (const s of deck.slides) {
+        for (const e of s.elements) {
+          elementCounts[e.type] = (elementCounts[e.type] ?? 0) + 1;
+        }
+      }
+      const summary = {
+        id: deck.id,
+        title: deck.title,
+        slides: deck.slides.length,
+        theme: deck.theme?.name,
+        elementCounts
+      };
+      return textResult(JSON.stringify(summary, null, 2), summary);
+    },
+    false
+  );
+  reg(
+    "deck_get",
+    "Read the full deck JSON.",
+    {},
+    [],
+    () => {
+      const deck = adapter.getDeck();
+      return textResult(JSON.stringify(deck, null, 2), deck);
+    },
+    false
+  );
+  reg(
+    "slide_list",
+    "List slides in order \u2014 `{ id, layout, elementCount, title? }`.",
+    {},
+    [],
+    () => {
+      const deck = adapter.getDeck();
+      const list = deck.slides.map((s) => ({
+        id: s.id,
+        layout: s.layout,
+        elementCount: s.elements.length,
+        title: s.metadata?.title ?? firstTextContent(s)
+      }));
+      return textResult(JSON.stringify(list, null, 2), list);
+    },
+    false
+  );
+  reg(
+    "slide_get",
+    "Read a single slide's JSON by id.",
+    { id: { type: "string" } },
+    ["id"],
+    (args) => {
+      const id = str(args.id);
+      const slide = adapter.getDeck().slides.find((s) => s.id === id);
+      if (!slide) return errorResult(`Slide not found: ${id}`);
+      return textResult(JSON.stringify(slide, null, 2), slide);
+    },
+    false
+  );
+  reg(
+    "deck_set_title",
+    "Rename the deck.",
+    { title: { type: "string" } },
+    ["title"],
+    (args) => {
+      const title = str(args.title);
+      adapter.apply({ kind: "deck_set_title", title });
+      return textResult(`Title set to "${title}"`, { title });
+    },
+    true,
+    deckTarget
+  );
+  reg(
+    "deck_apply_theme",
+    "Apply a Theme to the deck. Pass either a built-in name (default / dark / vivid) or a full Theme object.",
+    { theme: { description: "Theme name string or Theme object." } },
+    ["theme"],
+    (args) => {
+      const t = args.theme;
+      let theme;
+      if (typeof t === "string") {
+        theme = { name: t };
+      } else if (t && typeof t === "object" && "name" in t) {
+        theme = t;
+      } else {
+        return errorResult("theme must be a string name or an object with a `name` field.");
+      }
+      adapter.apply({ kind: "deck_apply_theme", theme });
+      return textResult(`Applied theme: ${theme.name}`, { theme });
+    },
+    true,
+    deckTarget
+  );
+  reg(
+    "slide_add",
+    "Insert a slide at `index` (defaults to end). Returns the new slide's id. Accepts a partial slide payload.",
+    {
+      index: { type: "number" },
+      slide: { description: "Partial slide payload \u2014 id is auto-generated when absent." }
+    },
+    [],
+    (args) => {
+      const deck = adapter.getDeck();
+      const incoming = args.slide && typeof args.slide === "object" ? args.slide : {};
+      const slide = {
+        id: incoming.id ?? fancySlides.slideId(),
+        layout: incoming.layout ?? "blank",
+        elements: incoming.elements ?? [],
+        background: incoming.background,
+        transition: incoming.transition,
+        notes: incoming.notes,
+        metadata: incoming.metadata
+      };
+      const index = clamp(num(args.index, deck.slides.length), 0, deck.slides.length);
+      adapter.apply({ kind: "slide_add", index, slide });
+      return textResult(`Added slide ${slide.id} at index ${index}`, { id: slide.id, index });
+    },
+    true,
+    () => deckTarget()
+  );
+  reg(
+    "slide_remove",
+    "Delete a slide by id.",
+    { id: { type: "string" } },
+    ["id"],
+    (args) => {
+      const id = str(args.id);
+      adapter.apply({ kind: "slide_remove", id });
+      return textResult(`Removed slide ${id}`, { id });
+    },
+    true,
+    (args) => slideTarget(str(args?.id))
+  );
+  reg(
+    "slide_reorder",
+    "Move a slide to a new index.",
+    { id: { type: "string" }, toIndex: { type: "number" } },
+    ["id", "toIndex"],
+    (args) => {
+      const id = str(args.id);
+      const toIndex = num(args.toIndex, 0);
+      adapter.apply({ kind: "slide_reorder", id, toIndex });
+      return textResult(`Moved slide ${id} \u2192 ${toIndex}`, { id, toIndex });
+    },
+    true,
+    (args) => slideTarget(str(args?.id))
+  );
+  reg(
+    "slide_set_layout",
+    "Change a slide's layout preset.",
+    { id: { type: "string" }, layout: { type: "string" } },
+    ["id", "layout"],
+    (args) => {
+      const id = str(args.id);
+      const layout = str(args.layout);
+      adapter.apply({ kind: "slide_set_layout", id, layout: layout ?? "blank" });
+      return textResult(`Slide ${id} layout \u2192 ${layout}`, { id, layout });
+    },
+    true,
+    (args) => slideTarget(str(args?.id))
+  );
+  reg(
+    "slide_set_notes",
+    "Set a slide's speaker notes.",
+    { id: { type: "string" }, notes: { type: "string" } },
+    ["id", "notes"],
+    (args) => {
+      const id = str(args.id);
+      const notes = str(args.notes);
+      adapter.apply({ kind: "slide_set_notes", id, notes });
+      return textResult(`Notes updated on slide ${id}`, { id });
+    },
+    true,
+    (args) => slideTarget(str(args?.id))
+  );
+  reg(
+    "slide_set_background",
+    "Set or clear a slide's background.",
+    {
+      id: { type: "string" },
+      background: { description: "Background object `{ color?, image?, gradient? }` \u2014 pass null to clear." }
+    },
+    ["id"],
+    (args) => {
+      const id = str(args.id);
+      const bg = args.background && typeof args.background === "object" ? args.background : void 0;
+      adapter.apply({ kind: "slide_set_background", id, background: bg });
+      return textResult(`Background set on slide ${id}`, { id });
+    },
+    true,
+    (args) => slideTarget(str(args?.id))
+  );
+  reg(
+    "element_add",
+    "Insert an element on a slide. Returns the new element id.",
+    {
+      slideId: { type: "string" },
+      element: { description: "Partial element \u2014 type/x/y/w/h required, id auto-generated when absent." }
+    },
+    ["slideId", "element"],
+    (args) => {
+      const slideId = str(args.slideId);
+      const incoming = args.element && typeof args.element === "object" ? args.element : {};
+      if (!incoming.type) return errorResult("element.type is required.");
+      const element = {
+        id: incoming.id ?? fancySlides.elementId(),
+        ...incoming
+      };
+      adapter.apply({ kind: "element_add", slideId, element });
+      return textResult(`Added ${element.type} element ${element.id} on ${slideId}`, { id: element.id, slideId });
+    },
+    true,
+    (args) => slideTarget(str(args?.slideId))
+  );
+  reg(
+    "element_remove",
+    "Delete an element by id.",
+    { slideId: { type: "string" }, elementId: { type: "string" } },
+    ["slideId", "elementId"],
+    (args) => {
+      const slideId = str(args.slideId);
+      const elementId = str(args.elementId);
+      adapter.apply({ kind: "element_remove", slideId, elementId });
+      return textResult(`Removed element ${elementId} from ${slideId}`, { slideId, elementId });
+    },
+    true,
+    (args) => elementTarget(str(args?.slideId), str(args?.elementId))
+  );
+  reg(
+    "element_update",
+    "Patch arbitrary fields on an element. Only the keys in `patch` change.",
+    {
+      slideId: { type: "string" },
+      elementId: { type: "string" },
+      patch: { type: "object" }
+    },
+    ["slideId", "elementId", "patch"],
+    (args) => {
+      const slideId = str(args.slideId);
+      const elementId = str(args.elementId);
+      const patch = args.patch && typeof args.patch === "object" ? args.patch : {};
+      adapter.apply({ kind: "element_update", slideId, elementId, patch });
+      return textResult(`Patched element ${elementId}`, { keys: Object.keys(patch) });
+    },
+    true,
+    (args) => elementTarget(str(args?.slideId), str(args?.elementId))
+  );
+  reg(
+    "element_move",
+    "Set element x/y (slide-relative, 0..1).",
+    {
+      slideId: { type: "string" },
+      elementId: { type: "string" },
+      x: { type: "number" },
+      y: { type: "number" }
+    },
+    ["slideId", "elementId", "x", "y"],
+    (args) => {
+      const slideId = str(args.slideId);
+      const elementId = str(args.elementId);
+      const x = clamp(num(args.x, 0), 0, 1);
+      const y = clamp(num(args.y, 0), 0, 1);
+      adapter.apply({ kind: "element_move", slideId, elementId, x, y });
+      return textResult(`Moved element ${elementId} \u2192 (${x}, ${y})`, { x, y });
+    },
+    true,
+    (args) => elementTarget(str(args?.slideId), str(args?.elementId))
+  );
+  reg(
+    "element_resize",
+    "Set element width/height (slide-relative, 0..1).",
+    {
+      slideId: { type: "string" },
+      elementId: { type: "string" },
+      w: { type: "number" },
+      h: { type: "number" }
+    },
+    ["slideId", "elementId", "w", "h"],
+    (args) => {
+      const slideId = str(args.slideId);
+      const elementId = str(args.elementId);
+      const w = clamp(num(args.w, 0), 0, 1);
+      const h = clamp(num(args.h, 0), 0, 1);
+      adapter.apply({ kind: "element_resize", slideId, elementId, w, h });
+      return textResult(`Resized element ${elementId} \u2192 (${w}, ${h})`, { w, h });
+    },
+    true,
+    (args) => elementTarget(str(args?.slideId), str(args?.elementId))
+  );
+  return {
+    id: "slides",
+    title: "Slides",
+    dispose: () => {
+      for (const d of disposers.splice(0)) d();
+    }
+  };
+}
+function num(v, fallback = 0) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function str(v, fallback = "") {
+  return typeof v === "string" ? v : fallback;
+}
+function clamp(v, min, max) {
+  return Math.max(min, Math.min(max, v));
+}
+function firstTextContent(slide) {
+  for (const e of slide.elements) {
+    if (e.type === "text") {
+      const t = e.content;
+      if (typeof t === "string") return t.split("\n")[0]?.slice(0, 60);
+    }
+  }
+  return void 0;
+}
 function AgentPanel({ agent, activity, onSubmit, busy, actions, className, style }) {
   const scrollRef = react.useRef(null);
   const inputRef = react.useRef(null);
@@ -2217,6 +2593,7 @@ exports.registerFormBridge = registerFormBridge;
 exports.registerSceneBridge = registerSceneBridge;
 exports.registerScreensBridge = registerScreensBridge;
 exports.registerSheetsBridge = registerSheetsBridge;
+exports.registerSlidesBridge = registerSlidesBridge;
 exports.registerUndoTools = registerUndoTools;
 exports.resetActivityRegistry = resetActivityRegistry;
 exports.resetAllUndoStacks = resetAllUndoStacks;