@adminide-stack/yantra-mobile 12.0.121 → 12.0.123-alpha.0

package/lib/features/canvas/set/agent/tools.js

@@ -0,0 +1,580 @@
+import {KIT_ENTRIES}from'../supplyLibrary.js';import {SET_ASPECTS,MESH_TARGET_HEIGHT_M,newObjectId,vec3,lightingOf,DEFAULT_CAMERA}from'../setProject.js';import {describeSet,describeObjects}from'./snapshot.js';import {uniqueName,cameraFromShot,tidySet,removeObjects,updateObjects,placeObjects}from'./setOps.js';var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+class ToolInputError extends Error {
+}
+const argsOf = (raw) => raw && typeof raw === "object" ? raw : {};
+const isNum = (v) => typeof v === "number" && Number.isFinite(v);
+const str = (v) => typeof v === "string" ? v.trim() : "";
+const list = (v) => Array.isArray(v) ? v : [];
+const point = (v) => {
+  if (!v || typeof v !== "object") return void 0;
+  const raw = v;
+  const out = {};
+  if (isNum(raw.x)) out.x = raw.x;
+  if (isNum(raw.y)) out.y = raw.y;
+  if (isNum(raw.z)) out.z = raw.z;
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+function sizing(raw) {
+  const scaleXyz = point(raw.scale_xyz);
+  return __spreadValues(__spreadValues(__spreadValues({}, scaleXyz ? {
+    scaleXyz
+  } : {}), isNum(raw.scale) ? {
+    scale: raw.scale
+  } : {}), isNum(raw.height_m) ? {
+    heightM: raw.height_m
+  } : {});
+}
+function toPlacement(raw) {
+  const o = argsOf(raw);
+  const kit = str(o.kit) || str(o.kit_id) || str(o.kitId);
+  if (!kit) return null;
+  const position = point(o.position);
+  const rotation = point(o.rotation);
+  return __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+    kit
+  }, str(o.name) ? {
+    name: str(o.name)
+  } : {}), position ? {
+    position
+  } : {}), rotation ? {
+    rotation
+  } : {}), isNum(o.rotation_y) ? {
+    rotationY: o.rotation_y
+  } : {}), sizing(o)), str(o.color) ? {
+    color: str(o.color)
+  } : {}), o.locked === true ? {
+    locked: true
+  } : {});
+}
+function toUpdate(raw) {
+  const o = argsOf(raw);
+  const id = str(o.id);
+  if (!id) return null;
+  const position = point(o.position);
+  const rotation = point(o.rotation);
+  return __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+    id
+  }, str(o.name) ? {
+    name: str(o.name)
+  } : {}), position ? {
+    position
+  } : {}), rotation ? {
+    rotation
+  } : {}), isNum(o.rotation_y) ? {
+    rotationY: o.rotation_y
+  } : {}), sizing(o)), str(o.color) ? {
+    color: str(o.color)
+  } : {}), typeof o.hidden === "boolean" ? {
+    hidden: o.hidden
+  } : {}), typeof o.locked === "boolean" ? {
+    locked: o.locked
+  } : {});
+}
+const KIT_IDS = KIT_ENTRIES.map((entry) => entry.id).join(", ");
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function tool(name, description, properties, required = []) {
+  return {
+    type: "function",
+    function: {
+      name,
+      description,
+      parameters: {
+        type: "object",
+        properties,
+        required
+      }
+    }
+  };
+}
+const VEC3 = {
+  type: "object",
+  description: "Metres. x is right, y is up, z is toward the default camera.",
+  properties: {
+    x: {
+      type: "number"
+    },
+    y: {
+      type: "number"
+    },
+    z: {
+      type: "number"
+    }
+  }
+};
+const SIZING = {
+  height_m: {
+    type: "number",
+    description: "The height this piece should end up, in metres. The simplest way to size anything."
+  },
+  scale: {
+    type: "number",
+    description: "Uniform multiplier on the kit size. Ignored when height_m is given."
+  },
+  scale_xyz: __spreadProps(__spreadValues({}, VEC3), {
+    description: "Non-uniform scale, when a piece has to be stretched (a plank into a 2m shelf)."
+  })
+};
+const PLACEMENT = {
+  type: "object",
+  properties: __spreadProps(__spreadValues({
+    kit: {
+      type: "string",
+      description: `Supply library id: ${KIT_IDS}.`
+    },
+    name: {
+      type: "string",
+      description: 'What this is in the shot ("Counter", "Barista"), not the shape.'
+    },
+    position: __spreadProps(__spreadValues({}, VEC3), {
+      description: "Where the BASE of the piece sits. Floor level is y 0; on a table is y 0.77."
+    }),
+    rotation_y: {
+      type: "number",
+      description: "Turn around the vertical axis, in degrees."
+    }
+  }, SIZING), {
+    color: {
+      type: "string",
+      description: 'Hex tint, e.g. "#c9b79c". Omit to keep the kit colour.'
+    },
+    locked: {
+      type: "boolean",
+      description: "Lock set dressing the user should not drag by accident - floors and walls."
+    }
+  }),
+  required: ["kit"]
+};
+const SET_AGENT_TOOLS = [tool("block_set", 'Place stock geometry. mode "replace" blocks a whole new set in one call (use this for a fresh brief); mode "add" keeps what is there and adds to it.', {
+  mode: {
+    type: "string",
+    enum: ["replace", "add"],
+    description: 'Default "add".'
+  },
+  objects: {
+    type: "array",
+    items: PLACEMENT,
+    description: "The pieces to place, in the order they matter."
+  }
+}, ["objects"]), tool("update_objects", "Move, turn, resize, recolour, hide or lock objects already in the set. Every field is optional: send only what changes.", {
+  updates: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: __spreadProps(__spreadValues({
+        id: {
+          type: "string",
+          description: "Object id, copied from the snapshot."
+        },
+        name: {
+          type: "string"
+        },
+        position: VEC3,
+        rotation_y: {
+          type: "number"
+        }
+      }, SIZING), {
+        color: {
+          type: "string"
+        },
+        hidden: {
+          type: "boolean"
+        },
+        locked: {
+          type: "boolean"
+        }
+      }),
+      required: ["id"]
+    }
+  }
+}, ["updates"]), tool("remove_objects", "Take objects out of the set.", {
+  ids: {
+    type: "array",
+    items: {
+      type: "string"
+    },
+    description: "Object ids."
+  }
+}, ["ids"]), tool("set_camera", "Put the camera on a shot. Describe it as distance, height and lens rather than coordinates where you can - distance is measured on the ground from the target.", {
+  target: __spreadProps(__spreadValues({}, VEC3), {
+    description: "What the camera looks at. Aim at the interesting height: a standing figure's chest is ~1.2m."
+  }),
+  distance: {
+    type: "number",
+    description: "Metres from the target: wide room 5-7, full figure 4, product 1.2-1.8, portrait 1.3."
+  },
+  height: {
+    type: "number",
+    description: "Lens height in metres: 1.6 standing, 1.2 seated, below 0.8 is a low angle."
+  },
+  azimuth_deg: {
+    type: "number",
+    description: "Where the camera stands around the target. 0 is straight in front (+Z), 90 is to the right (+X)."
+  },
+  lens_mm: {
+    type: "number",
+    description: "35mm-equivalent focal length: 24 wide, 35 normal, 50 product, 85 portrait."
+  },
+  fov: {
+    type: "number",
+    description: "Vertical field of view in degrees, if you would rather set it directly."
+  },
+  position: __spreadProps(__spreadValues({}, VEC3), {
+    description: "An exact camera position; overrides distance/height/azimuth."
+  })
+}), tool("set_light", "Aim the key light and set the ambient fill.", {
+  azimuth_deg: {
+    type: "number",
+    description: "Direction around the set, in degrees."
+  },
+  elevation_deg: {
+    type: "number",
+    description: "Height above the horizon: 40+ is flattering, 15-25 throws long shadows."
+  },
+  key: {
+    type: "number",
+    description: "Key intensity, 0-10. 2.6 is a normal key."
+  },
+  ambient: {
+    type: "number",
+    description: "Fill intensity, 0-5. Raise it for a soft overcast look."
+  }
+}), tool("set_world", "The backdrop behind the set, and the ground under it.", {
+  background: {
+    type: "string",
+    description: "Hex backdrop colour, used when there is no panorama."
+  },
+  show_ground: {
+    type: "boolean",
+    description: "The ground plane that catches contact shadows. Almost always true."
+  },
+  rotation_deg: {
+    type: "number",
+    description: "Turn a generated panorama to place its sun or landmark."
+  }
+}), tool("set_format", "The aspect the render is framed to, and the set's name.", {
+  aspect: {
+    type: "string",
+    enum: [...SET_ASPECTS],
+    description: "Decide this before blocking: it changes where things go."
+  },
+  title: {
+    type: "string",
+    description: "A short name for the set."
+  }
+}), tool("generate_object", "Turn a prompt, or a still already on the board, into a real 3D object and place it. Takes 45-120 seconds - use it for the one or two pieces the shot is about.", {
+  prompt: {
+    type: "string",
+    description: 'The object alone, plainly described: "a chipped enamel coffee mug". No scene, no background.'
+  },
+  still_id: {
+    type: "string",
+    description: "A still from the board to generate from instead of a prompt."
+  },
+  name: {
+    type: "string",
+    description: "What it is in the shot."
+  },
+  position: __spreadProps(__spreadValues({}, VEC3), {
+    description: "Where its base sits. Defaults to the camera target."
+  }),
+  height_m: {
+    type: "number",
+    description: `The height it should end up. Generated meshes arrive normalised to ${MESH_TARGET_HEIGHT_M}m, so always say.`
+  }
+}), tool("generate_world", "Paint the 360 panorama behind the set. A few seconds.", {
+  prompt: {
+    type: "string",
+    description: 'The place, plainly: "a rain-slicked city street at night, neon signage". No subject.'
+  }
+}, ["prompt"]), tool("get_set", "Read the set back as it stands now.", {})];
+function committed(ctx, project, said, label, detail) {
+  const tidy = tidySet(project);
+  ctx.commit(tidy);
+  return __spreadValues({
+    result: `${said}
+
+${describeObjects(tidy)}`,
+    label
+  }, detail ? {
+    detail
+  } : {});
+}
+function blockSet(args, ctx) {
+  const specs = list(args.objects).map(toPlacement).filter((s) => s !== null);
+  if (specs.length === 0) throw new ToolInputError(`no placeable objects - every entry needs a "kit" from: ${KIT_IDS}`);
+  const mode = args.mode === "replace" ? "replace" : "add";
+  const {
+    project,
+    placed,
+    unknownKits
+  } = placeObjects(ctx.project(), specs, mode);
+  if (placed.length === 0) throw new ToolInputError(`none of those kit ids exist (${unknownKits.join(", ")}); use one of: ${KIT_IDS}`);
+  const dropped = unknownKits.length > 0 ? ` Dropped ${plural(unknownKits.length, "entry")} with an unknown kit (${unknownKits.join(", ")}); the library is: ${KIT_IDS}.` : "";
+  const verb = mode === "replace" ? "Replaced the set with" : "Added";
+  const camera = project.camera;
+  const untouched = camera.position.x === DEFAULT_CAMERA.position.x && camera.position.y === DEFAULT_CAMERA.position.y && camera.position.z === DEFAULT_CAMERA.position.z;
+  const nextStep = untouched ? " The camera has NOT been set - it is still on the default angle. Call set_camera now; the shot is not blocked until you do." : "";
+  return committed(ctx, project, `${verb} ${plural(placed.length, "object")}.${dropped}${nextStep}`, `${mode === "replace" ? "Blocked" : "Added"} ${plural(placed.length, "object")}`, placed.slice(0, 6).map((o) => o.name).join(", "));
+}
+function updateTool(args, ctx) {
+  const specs = list(args.updates).map(toUpdate).filter((s) => s !== null);
+  if (specs.length === 0) throw new ToolInputError('no updates - every entry needs the "id" of an object in the set');
+  const {
+    project,
+    updated,
+    missing
+  } = updateObjects(ctx.project(), specs);
+  if (updated.length === 0) throw new ToolInputError(`no object in the set has ${missing.length === 1 ? `id ${missing[0]}` : `any of those ids (${missing.join(", ")})`}`);
+  const note = missing.length > 0 ? ` No object has ${missing.length === 1 ? `id ${missing[0]}` : `ids ${missing.join(", ")}`}.` : "";
+  return committed(ctx, project, `Updated ${plural(updated.length, "object")}.${note}`, `Updated ${plural(updated.length, "object")}`, updated.map((o) => o.name).slice(0, 6).join(", "));
+}
+function removeTool(args, ctx) {
+  const ids = list(args.ids).map((v) => str(v)).filter(Boolean);
+  if (ids.length === 0) throw new ToolInputError("no ids given");
+  const {
+    project,
+    removed,
+    missing
+  } = removeObjects(ctx.project(), ids);
+  if (removed.length === 0) throw new ToolInputError(`no object in the set has ${missing.length === 1 ? `id ${missing[0]}` : `any of those ids (${missing.join(", ")})`}`);
+  const note = missing.length > 0 ? ` ${plural(missing.length, "id")} matched nothing.` : "";
+  return committed(ctx, project, `Removed ${plural(removed.length, "object")}.${note}`, `Removed ${plural(removed.length, "object")}`, removed.map((o) => o.name).join(", "));
+}
+function cameraTool(args, ctx) {
+  var _a;
+  const spec = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, point(args.target) ? {
+    target: point(args.target)
+  } : {}), point(args.position) ? {
+    position: point(args.position)
+  } : {}), isNum(args.distance) ? {
+    distance: args.distance
+  } : {}), isNum(args.height) ? {
+    height: args.height
+  } : {}), isNum(args.azimuth_deg) ? {
+    azimuthDeg: args.azimuth_deg
+  } : {}), isNum(args.lens_mm) ? {
+    lensMm: args.lens_mm
+  } : {}), isNum(args.fov) ? {
+    fov: args.fov
+  } : {});
+  if (Object.keys(spec).length === 0) throw new ToolInputError("nothing to change - give a distance, a height, an azimuth, a lens or a target");
+  const project = ctx.project();
+  const camera = cameraFromShot(project.camera, spec);
+  const next = tidySet(__spreadProps(__spreadValues({}, project), {
+    camera
+  }));
+  ctx.commit(next);
+  (_a = ctx.applyCamera) == null ? void 0 : _a.call(ctx, next.camera);
+  const mm = isNum(args.lens_mm) ? `${Math.round(args.lens_mm)}mm` : `${Math.round(next.camera.fov)}\xB0`;
+  const away = Math.hypot(next.camera.position.x - next.camera.target.x, next.camera.position.z - next.camera.target.z);
+  return {
+    result: `Camera at ${[next.camera.position.x, next.camera.position.y, next.camera.position.z].map((v) => Math.round(v * 100) / 100).join(",")} looking at ${[next.camera.target.x, next.camera.target.y, next.camera.target.z].map((v) => Math.round(v * 100) / 100).join(",")}, ${Math.round(next.camera.fov)}\xB0 fov.`,
+    label: "Set the camera",
+    detail: `${mm} \xB7 ${Math.round(away * 10) / 10}m out \xB7 ${Math.round(next.camera.position.y * 100) / 100}m up`
+  };
+}
+function lightTool(args, ctx) {
+  const project = ctx.project();
+  const lighting = __spreadValues({}, lightingOf(project));
+  let touched = false;
+  if (isNum(args.azimuth_deg)) {
+    lighting.keyAzimuthDeg = (args.azimuth_deg % 360 + 360) % 360;
+    touched = true;
+  }
+  if (isNum(args.elevation_deg)) {
+    lighting.keyElevationDeg = Math.min(89, Math.max(1, args.elevation_deg));
+    touched = true;
+  }
+  if (isNum(args.key)) {
+    lighting.keyIntensity = Math.min(10, Math.max(0, args.key));
+    touched = true;
+  }
+  if (isNum(args.ambient)) {
+    lighting.ambientIntensity = Math.min(5, Math.max(0, args.ambient));
+    touched = true;
+  }
+  if (!touched) throw new ToolInputError("nothing to change - give an azimuth, an elevation, a key or an ambient");
+  ctx.commit(__spreadProps(__spreadValues({}, project), {
+    lighting
+  }));
+  return {
+    result: `Key light from ${Math.round(lighting.keyAzimuthDeg)}\xB0 at ${Math.round(lighting.keyElevationDeg)}\xB0 above the horizon, intensity ${lighting.keyIntensity}, ambient ${lighting.ambientIntensity}.`,
+    label: "Set the light",
+    detail: `${Math.round(lighting.keyAzimuthDeg)}\xB0 / ${Math.round(lighting.keyElevationDeg)}\xB0`
+  };
+}
+function worldTool(args, ctx) {
+  const project = ctx.project();
+  const world = __spreadValues({}, project.world);
+  let touched = false;
+  if (/^#[0-9a-f]{3,8}$/i.test(str(args.background))) {
+    world.background = str(args.background);
+    touched = true;
+  }
+  if (typeof args.show_ground === "boolean") {
+    world.showGround = args.show_ground;
+    touched = true;
+  }
+  if (isNum(args.rotation_deg)) {
+    world.rotationDeg = (args.rotation_deg % 360 + 360) % 360;
+    touched = true;
+  }
+  if (!touched) throw new ToolInputError("nothing to change - give a background colour, show_ground, or a rotation");
+  ctx.commit(__spreadProps(__spreadValues({}, project), {
+    world
+  }));
+  return {
+    result: `Backdrop ${world.background}, ground ${world.showGround ? "on" : "off"}, panorama turned ${Math.round(world.rotationDeg)}\xB0.`,
+    label: "Set the world"
+  };
+}
+function formatTool(args, ctx) {
+  const project = ctx.project();
+  const aspect = str(args.aspect);
+  const title = str(args.title);
+  if (aspect && !SET_ASPECTS.includes(aspect)) {
+    throw new ToolInputError(`aspect must be one of ${SET_ASPECTS.join(", ")}`);
+  }
+  if (!aspect && !title) throw new ToolInputError("nothing to change - give an aspect or a title");
+  ctx.commit(__spreadValues(__spreadValues(__spreadValues({}, project), aspect ? {
+    aspect
+  } : {}), title ? {
+    title
+  } : {}));
+  return {
+    result: `Framed ${aspect || project.aspect}${title ? `, called "${title}"` : ""}.`,
+    label: aspect ? `Framed ${aspect}` : "Renamed the set"
+  };
+}
+async function generateObjectTool(args, ctx) {
+  var _a, _b;
+  const prompt = str(args.prompt);
+  const stillId = str(args.still_id);
+  const still = stillId ? ctx.stills.find((s) => s.id === stillId) : void 0;
+  if (stillId && !still) {
+    throw new ToolInputError(ctx.stills.length > 0 ? `no still with id ${stillId}; the board has ${ctx.stills.map((s) => s.id).join(", ")}` : "there are no stills on the board to generate from");
+  }
+  if (!prompt && !still) throw new ToolInputError("give a prompt describing the object, or a still_id from the board");
+  const name = str(args.name) || (prompt ? prompt.slice(0, 28) : (_a = still == null ? void 0 : still.label) != null ? _a : "Object");
+  ctx.progress(`Generating ${name}\u2026`);
+  const result = await ctx.services.generateObject(__spreadValues(__spreadProps(__spreadValues(__spreadValues({}, prompt ? {
+    prompt
+  } : {}), still ? {
+    imageUrl: still.src
+  } : {}), {
+    onProgress: (message) => ctx.progress(`${name}: ${message}`)
+  }), ctx.signal ? {
+    signal: ctx.signal
+  } : {}));
+  if (!result.modelUrl) throw new Error("the generator returned no model");
+  const project = ctx.project();
+  const height = isNum(args.height_m) && args.height_m > 0 ? args.height_m : null;
+  const factor = height ? height / MESH_TARGET_HEIGHT_M : 1;
+  const position = point(args.position);
+  const next = __spreadProps(__spreadValues({}, project), {
+    objects: [...project.objects, __spreadProps(__spreadValues(__spreadValues({
+      id: newObjectId(),
+      name: uniqueName(project.objects.map((o) => o.name), name),
+      source: "mesh",
+      modelUrl: result.modelUrl
+    }, result.previewUrl ? {
+      previewUrl: result.previewUrl
+    } : {}), still ? {
+      sourceImageUrl: still.src
+    } : {}), {
+      position: {
+        x: isNum(position == null ? void 0 : position.x) ? position.x : project.camera.target.x,
+        y: isNum(position == null ? void 0 : position.y) ? position.y : 0,
+        z: isNum(position == null ? void 0 : position.z) ? position.z : project.camera.target.z
+      },
+      rotation: vec3(),
+      scale: vec3(factor, factor, factor)
+    })]
+  });
+  return committed(ctx, next, `Generated "${name}" and placed it${height ? ` at ${height}m tall` : ` at its default ${MESH_TARGET_HEIGHT_M}m - set height_m if that is wrong`}.`, `Generated ${name}`, (_b = result.modelUrl.split("/").pop()) == null ? void 0 : _b.slice(0, 40));
+}
+async function generateWorldTool(args, ctx) {
+  const prompt = str(args.prompt);
+  if (!prompt) throw new ToolInputError("give a prompt describing the place");
+  ctx.progress("Painting the world\u2026");
+  const result = await ctx.services.generateWorld(prompt);
+  if (!result.imageUrl) throw new Error("the generator returned no panorama");
+  const project = ctx.project();
+  ctx.commit(__spreadProps(__spreadValues({}, project), {
+    world: __spreadValues(__spreadProps(__spreadValues({}, project.world), {
+      imageUrl: result.imageUrl,
+      prompt
+    }), result.model ? {
+      model: result.model
+    } : {})
+  }));
+  return {
+    result: `The set now stands in: ${prompt}.`,
+    label: "Generated the world",
+    detail: prompt.slice(0, 60)
+  };
+}
+async function executeSetTool(name, rawArgs, ctx) {
+  var _a;
+  const args = argsOf(rawArgs);
+  try {
+    switch (name) {
+      case "block_set":
+        return blockSet(args, ctx);
+      case "update_objects":
+        return updateTool(args, ctx);
+      case "remove_objects":
+        return removeTool(args, ctx);
+      case "set_camera":
+        return cameraTool(args, ctx);
+      case "set_light":
+        return lightTool(args, ctx);
+      case "set_world":
+        return worldTool(args, ctx);
+      case "set_format":
+        return formatTool(args, ctx);
+      case "generate_object":
+        return await generateObjectTool(args, ctx);
+      case "generate_world":
+        return await generateWorldTool(args, ctx);
+      case "get_set":
+        return {
+          result: describeSet(ctx.project(), ctx.stills),
+          label: "Read the set"
+        };
+      default:
+        return {
+          result: `error: unknown tool "${name}"`,
+          label: `Unknown tool ${name}`
+        };
+    }
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") throw err;
+    if ((_a = ctx.signal) == null ? void 0 : _a.aborted) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    const kind = err instanceof ToolInputError ? "bad arguments" : "failed";
+    return {
+      result: `error (${kind}): ${message}`,
+      label: `${name.replace(/_/g, " ")} ${kind}`,
+      detail: message.length > 80 ? `${message.slice(0, 79)}\u2026` : message
+    };
+  }
+}export{SET_AGENT_TOOLS,executeSetTool};//# sourceMappingURL=tools.js.map