@duckmind/dm-windows-x64 0.63.0 → 0.63.6

package/extensions/dm-skills-manager/extensions/skills-manager/toggle.js

@@ -0,0 +1,54 @@
+import { relative, dirname } from "node:path";
+import { getAgentDir, SettingsManager } from "@duckmind/dm-coding-agent";
+import { findProjectDmDir, projectSettingsTrusted } from "./paths.js";
+function updatePatterns(current, pattern, enabled) {
+  const updated = current.filter((entry) => {
+    const stripped = entry.startsWith("!") || entry.startsWith("+") || entry.startsWith("-") ? entry.slice(1) : entry;
+    return stripped !== pattern;
+  });
+  updated.push(`${enabled ? "+" : "-"}${pattern}`);
+  return updated;
+}
+function getTopLevelPattern(skill, cwd) {
+  const baseDir = skill.scope === "project" ? findProjectDmDir(cwd) : getAgentDir();
+  return relative(baseDir, skill.path);
+}
+function getPackagePattern(skill) {
+  const baseDir = skill.baseDir ?? dirname(skill.path);
+  return relative(baseDir, skill.path);
+}
+function hasPackageFilters(pkg) {
+  return pkg.extensions !== undefined || pkg.skills !== undefined || pkg.prompts !== undefined || pkg.themes !== undefined;
+}
+export async function setSkillEnabled(cwd, skill, enabled) {
+  if (skill.scope === "temporary")
+    throw new Error("Temporary skills cannot be toggled.");
+  if (skill.scope === "project" && !projectSettingsTrusted(cwd))
+    throw new Error("Project skills cannot be toggled before project trust is active.");
+  const settingsManager = SettingsManager.create(cwd, getAgentDir(), { projectTrusted: projectSettingsTrusted(cwd) });
+  if (skill.origin === "top-level") {
+    const settings = skill.scope === "project" ? settingsManager.getProjectSettings() : settingsManager.getGlobalSettings();
+    const updated = updatePatterns([...settings.skills ?? []], getTopLevelPattern(skill, cwd), enabled);
+    if (skill.scope === "project")
+      settingsManager.setProjectSkillPaths(updated);
+    else
+      settingsManager.setSkillPaths(updated);
+    await settingsManager.flush();
+    return;
+  }
+  const settings = skill.scope === "project" ? settingsManager.getProjectSettings() : settingsManager.getGlobalSettings();
+  const packages = [...settings.packages ?? []];
+  const packageIndex = packages.findIndex((pkg) => (typeof pkg === "string" ? pkg : pkg.source) === skill.source);
+  if (packageIndex === -1)
+    throw new Error("Could not find the package settings entry for this skill.");
+  const packageEntry = packages[packageIndex];
+  const packageConfig = typeof packageEntry === "string" ? { source: packageEntry } : { ...packageEntry };
+  const updated = updatePatterns([...packageConfig.skills ?? []], getPackagePattern(skill), enabled);
+  packageConfig.skills = updated.length > 0 ? updated : undefined;
+  packages[packageIndex] = hasPackageFilters(packageConfig) ? packageConfig : packageConfig.source;
+  if (skill.scope === "project")
+    settingsManager.setProjectPackages(packages);
+  else
+    settingsManager.setPackages(packages);
+  await settingsManager.flush();
+}

package/extensions/dm-skills-manager/extensions/skills-manager/types.js

@@ -0,0 +1,14 @@
+export const EMPTY_REGISTRY = {
+  skills: [],
+  allSkills: [],
+  byName: new Map
+};
+export const LOCATION_OPTIONS = [
+  { value: "project", label: "Project", description: "Save in this project's .dm/skills directory." },
+  { value: "global", label: "Global", description: "Save in your user-level DM skills directory." }
+];
+export const CREATE_STEPS = [
+  { id: "name", title: "Name", hint: "Use lowercase letters, numbers, and hyphens, for example react-review.", optional: false, kind: "text" },
+  { id: "description", title: "Description", hint: "Describe what the skill does and when it should be used. Specific trigger language works best.", optional: false, kind: "text" },
+  { id: "location", title: "Visibility", hint: "Choose whether the skill is project-local or available in all DM sessions.", optional: false, kind: "choice", options: LOCATION_OPTIONS }
+];

package/extensions/dm-skills-manager/extensions/skills-manager/ui.js

@@ -0,0 +1,121 @@
+import { truncateToWidth, visibleWidth } from "@duckmind/dm-tui";
+import { ansiGreen, ansiYellow, KENDEX_MODAL_LOCK_SYMBOL } from "./constants.js";
+import { frameGlyphs, glyphs } from "./glyphs.js";
+export function inlineLine(text) {
+  return text.replace(/[\r\n]+/g, " ").replace(/\t/g, " ");
+}
+export function acquirekendexModalLock() {
+  const host = globalThis;
+  const existing = host[KENDEX_MODAL_LOCK_SYMBOL];
+  const lock = existing && typeof existing.depth === "number" ? existing : { depth: 0 };
+  host[KENDEX_MODAL_LOCK_SYMBOL] = lock;
+  lock.depth += 1;
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    lock.depth = Math.max(0, lock.depth - 1);
+  };
+}
+export function padAnsi(text, width) {
+  const safeWidth = Math.max(0, width);
+  const truncated = truncateToWidth(inlineLine(text), safeWidth, "");
+  return `${truncated}${" ".repeat(Math.max(0, safeWidth - visibleWidth(truncated)))}`;
+}
+export function toneText(theme, tone, text) {
+  if (tone === "error")
+    return theme.fg("error", text);
+  if (tone === "success")
+    return theme.fg("success", text);
+  return theme.fg("dim", text);
+}
+export function skillEntityTitle(theme, label) {
+  return theme.fg("text", theme.bold(label));
+}
+export function skillSectionTitle(theme, label) {
+  return theme.fg("muted", theme.bold(label));
+}
+export function skillSelectedLine(theme, line, width) {
+  return theme.bg("selectedBg", padAnsi(line, width));
+}
+export function skillKeyHints(theme, hints) {
+  return hints.map(([key, description]) => `${ansiYellow(key)} ${theme.fg("dim", description)}`).join(theme.fg("dim", ` ${glyphs().bullet.trim()} `));
+}
+function frameLine(theme, line, innerWidth) {
+  const clipped = truncateToWidth(inlineLine(line), innerWidth, theme.fg("dim", "..."));
+  const frame = frameGlyphs();
+  return `${theme.fg("borderAccent", `${frame.v} `)}${padAnsi(clipped, innerWidth)}${theme.fg("borderAccent", ` ${frame.v}`)}`;
+}
+function fitFrameBody(theme, lines, fixedInnerRows) {
+  if (fixedInnerRows === undefined)
+    return lines;
+  const rowCount = Math.max(1, Math.floor(fixedInnerRows));
+  if (lines.length > rowCount) {
+    const hidden = lines.length - rowCount + 1;
+    return [...lines.slice(0, Math.max(0, rowCount - 1)), theme.fg("dim", `↓ ${hidden} more line(s)`)].slice(0, rowCount);
+  }
+  if (lines.length < rowCount)
+    return [...lines, ...Array.from({ length: rowCount - lines.length }, () => "")];
+  return lines;
+}
+export function renderFrame(theme, width, lines, fixedInnerRows, title = "", right = "") {
+  const body = fitFrameBody(theme, lines, fixedInnerRows);
+  if (width < 6)
+    return body.map((line) => truncateToWidth(inlineLine(line), width, ""));
+  const innerWidth = Math.max(1, width - 4);
+  const frame = frameGlyphs();
+  const top = () => {
+    const contentWidth = innerWidth + 2;
+    if (!title && !right)
+      return theme.fg("borderAccent", `${frame.tl}${frame.h.repeat(contentWidth)}${frame.tr}`);
+    const rightPlain = right ? ` ${right} ` : "";
+    const titleBudget = Math.max(1, contentWidth - visibleWidth(rightPlain) - 1);
+    const titlePlain = title ? ` ${truncateToWidth(title, Math.max(1, titleBudget - 2), glyphs().ellipsis)} ` : "";
+    const fill = Math.max(1, contentWidth - visibleWidth(titlePlain) - visibleWidth(rightPlain));
+    return `${theme.fg("borderAccent", frame.tl)}${titlePlain ? ansiGreen(titlePlain) : ""}${theme.fg("borderAccent", frame.h.repeat(fill))}${rightPlain ? theme.fg("dim", rightPlain) : ""}${theme.fg("borderAccent", frame.tr)}`;
+  };
+  return [
+    top(),
+    ...body.map((line) => frameLine(theme, line, innerWidth)),
+    theme.fg("borderAccent", `${frame.bl}${frame.h.repeat(innerWidth + 2)}${frame.br}`)
+  ].map((line) => truncateToWidth(inlineLine(line), width, ""));
+}
+function centerLines(lines, width) {
+  const renderedWidth = lines.reduce((max, line) => Math.max(max, visibleWidth(line)), 0);
+  const leftPad = Math.max(0, Math.floor((width - renderedWidth) / 2));
+  return leftPad === 0 ? lines : lines.map((line) => `${" ".repeat(leftPad)}${line}`);
+}
+export function renderCenteredDialog(theme, width, lines, maxInnerWidth = 68) {
+  if (width < 8)
+    return lines.map((line) => truncateToWidth(line, width, ""));
+  const innerWidth = Math.max(1, Math.min(width - 4, maxInnerWidth));
+  const frame = frameGlyphs();
+  const framed = [
+    theme.fg("borderAccent", `${frame.tl}${frame.h.repeat(innerWidth + 2)}${frame.tr}`),
+    ...lines.map((line) => frameLine(theme, line, innerWidth)),
+    theme.fg("borderAccent", `${frame.bl}${frame.h.repeat(innerWidth + 2)}${frame.br}`)
+  ];
+  return centerLines(framed, width);
+}
+export function getEditorTheme(theme) {
+  return {
+    borderColor: (text) => theme.fg("accent", text),
+    selectList: {
+      selectedPrefix: (text) => theme.fg("accent", text),
+      selectedText: (text) => theme.bg("selectedBg", theme.fg("text", text)),
+      description: (text) => theme.fg("muted", text),
+      scrollInfo: (text) => theme.fg("dim", text),
+      noMatch: (text) => theme.fg("warning", text)
+    }
+  };
+}
+export function scopeLabel(skill) {
+  return skill.scope === "project" ? "project" : skill.scope === "user" ? "global" : "temporary";
+}
+export function packageLabel(skill) {
+  return skill.origin === "package" && skill.source ? skill.source : undefined;
+}
+export function skillLocation(skill) {
+  return skill.origin === "package" ? skill.source : skill.path;
+}

package/extensions/dm-skills-manager/extensions/skills-manager.js

@@ -0,0 +1,111 @@
+import { INSTALL_SYMBOL } from "./skills-manager/constants.js";
+import { createSkillFromAnswers } from "./skills-manager/creation.js";
+import { showSkillsManager } from "./skills-manager/dialog.js";
+import { recordProjectTrust } from "./skills-manager/paths.js";
+import { deleteSkill, loadSkillRegistry } from "./skills-manager/registry.js";
+import { settingBoolean, updatePackageConfig } from "./skills-manager/settings.js";
+import { patchInteractiveModeStartupSkillsBlock, setStartupHideEnabled } from "./skills-manager/startup.js";
+import { setSkillEnabled } from "./skills-manager/toggle.js";
+import { EMPTY_REGISTRY } from "./skills-manager/types.js";
+function errorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.length > 180 ? `${message.slice(0, 179)}…` : message;
+}
+function insertNativeSkillCommand(ctx, skill) {
+  ctx.ui.pasteToEditor(`/skill:${skill.name}
+`);
+}
+function dmThinkingLevel(value) {
+  if (value === "max")
+    return "xhigh";
+  return value === "off" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" ? value : "off";
+}
+export default function skillsManager(pi) {
+  const guard = pi;
+  if (guard[INSTALL_SYMBOL])
+    return;
+  guard[INSTALL_SYMBOL] = true;
+  patchInteractiveModeStartupSkillsBlock();
+  setStartupHideEnabled(settingBoolean("enabled", true) && settingBoolean("hideStartupSkillsBlock", true));
+  let registry = EMPTY_REGISTRY;
+  const enabledAtLoad = settingBoolean("enabled", true);
+  if (!enabledAtLoad) {
+    const enableRecovery = async (ctx) => {
+      updatePackageConfig(ctx.cwd, { enabled: true });
+      ctx.ui.notify("Skills Manager enabled. Reloading...", "info");
+      await ctx.reload();
+    };
+    pi.registerCommand("skill", {
+      description: "Skills manager recovery command.",
+      handler: async (args, ctx) => {
+        if (args.trim().toLowerCase() !== "enable") {
+          ctx.ui.notify("Skills Manager is disabled. Run /skill:enable, then /reload.", "warning");
+          return;
+        }
+        await enableRecovery(ctx);
+      }
+    });
+    pi.registerCommand("skill:enable", {
+      description: "Re-enable the skills manager",
+      handler: async (_args, ctx) => enableRecovery(ctx)
+    });
+    return;
+  }
+  async function refreshRegistry(cwd) {
+    registry = await loadSkillRegistry(cwd);
+    return registry;
+  }
+  async function prepareSession(ctx) {
+    recordProjectTrust(ctx);
+    setStartupHideEnabled(settingBoolean("enabled", true, ctx.cwd) && settingBoolean("hideStartupSkillsBlock", true, ctx.cwd));
+    try {
+      await refreshRegistry(ctx.cwd);
+    } catch (error) {
+      registry = EMPTY_REGISTRY;
+      ctx.ui.notify(`Skills Manager failed to load registry: ${errorMessage(error)}`, "error");
+    }
+    return false;
+  }
+  pi.registerCommand("skill", {
+    description: "DM skills manager view. Native skills remain /skill:name.",
+    handler: async (args, ctx) => {
+      const rawArgs = args.trim();
+      const trimmed = rawArgs.toLowerCase();
+      if (trimmed === "enable") {
+        updatePackageConfig(ctx.cwd, { enabled: true });
+        ctx.ui.notify("Skills Manager already enabled.", "info");
+        return;
+      }
+      if (trimmed === "disable") {
+        updatePackageConfig(ctx.cwd, { enabled: false });
+        ctx.ui.notify("Skills Manager disabled. Run /reload to unload commands/hooks.", "info");
+        return;
+      }
+      if (rawArgs) {
+        ctx.ui.notify("Use /skill:name for native skill invocation, or /skill with no arguments for the manager.", "warning");
+        return;
+      }
+      if (!ctx.hasUI) {
+        ctx.ui.notify("/skill manager requires interactive mode", "warning");
+        return;
+      }
+      try {
+        await refreshRegistry(ctx.cwd);
+      } catch (error) {
+        ctx.ui.notify(`Failed to load skills list: ${errorMessage(error)}`, "error");
+        return;
+      }
+      const selection = await showSkillsManager(ctx, registry, {
+        onCreate: async (answers, signal) => await createSkillFromAnswers(ctx, answers, { thinkingLevel: dmThinkingLevel(pi.getThinkingLevel()), signal }),
+        onDelete: async (skill) => await deleteSkill(ctx, skill),
+        onToggle: async (skill, enabled) => await setSkillEnabled(ctx.cwd, skill, enabled),
+        onRefresh: async () => await refreshRegistry(ctx.cwd)
+      });
+      if (selection)
+        insertNativeSkillCommand(ctx, selection);
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    await prepareSession(ctx);
+  });
+}

package/extensions/dm-skills-manager/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "dm-skills-manager",
+  "version": "2.0.0",
+  "description": "Skills manager for DM with browsing, preview, insertion, creation, editing, renaming, deletion, and enablement controls.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "duckmind",
+    "dm",
+    "dm-package",
+    "dm-extension",
+    "skills",
+    "manager"
+  ],
+  "dm": {
+    "extensions": [
+      "./extensions/skills-manager.js"
+    ],
+    "image": "https://raw.githubusercontent.com/vanillagreencom/kendex/9e4bc7e8ffa832e8d86b6e849cff1a108a679225/pi-extensions/pi-skills-manager/assets/skills-manager.png"
+  },
+  "kendex": {
+    "extensionManager": {
+      "displayName": "Skills Manager",
+      "settings": [
+        {
+          "key": "enabled",
+          "label": "Enable skills manager",
+          "description": "Register the /skill manager view, startup skill-list hiding, and skills management UI. If disabled, /skill enable remains available as a recovery command. Native /skill:name commands stay controlled by DM's Skill commands setting.",
+          "type": "boolean",
+          "default": true,
+          "category": "General",
+          "apply": "reload",
+          "requiresReload": true
+        },
+        {
+          "key": "glyphStyle",
+          "label": "Glyph style",
+          "description": "Glyphs for kendex-owned UI chrome. Unicode is the default; ASCII uses plain box/status/separator characters for terminal compatibility. DM tool renderer's global override wins when set.",
+          "type": "enum",
+          "enumValues": [
+            "unicode",
+            "ascii"
+          ],
+          "default": "unicode",
+          "category": "Rendering",
+          "apply": "live"
+        },
+        {
+          "key": "hideStartupSkillsBlock",
+          "label": "Hide startup skills block",
+          "description": "Hide DM's built-in startup [Skills] list so skills are managed through the dedicated menu instead.",
+          "type": "boolean",
+          "default": true,
+          "category": "Integration",
+          "apply": "reload",
+          "requiresReload": true
+        },
+        {
+          "key": "aiGenerationEnabled",
+          "label": "AI skill generation",
+          "description": "Use the currently selected model/thinking level to draft new SKILL.md files. If unavailable or disabled, a deterministic fallback template is used.",
+          "type": "boolean",
+          "default": true,
+          "category": "Creation",
+          "apply": "live"
+        },
+        {
+          "key": "defaultCreateLocation",
+          "label": "Default create location",
+          "description": "Initial visibility choice when creating a skill.",
+          "type": "enum",
+          "enumValues": [
+            "project",
+            "global"
+          ],
+          "default": "project",
+          "category": "Creation",
+          "apply": "live"
+        },
+        {
+          "key": "popupWidth",
+          "label": "Popup width",
+          "description": "Preferred overlay width. Accepts a number of columns or a percentage string such as 82%.",
+          "type": "string",
+          "default": "82%",
+          "category": "UI",
+          "apply": "live"
+        },
+        {
+          "key": "popupMaxHeight",
+          "label": "Popup max height",
+          "description": "Maximum overlay height. Accepts a number of rows or a percentage string.",
+          "type": "string",
+          "default": "86%",
+          "category": "UI",
+          "apply": "live"
+        },
+        {
+          "key": "listRows",
+          "label": "Visible list rows",
+          "description": "Maximum list rows shown before scrolling in browse mode. Short terminals shrink this to keep popup controls visible.",
+          "type": "number",
+          "default": 14,
+          "category": "UI",
+          "apply": "live"
+        }
+      ]
+    }
+  },
+  "peerDependenciesMeta": {
+    "@duckmind/dm-ai": {
+      "optional": true
+    },
+    "@duckmind/dm-coding-agent": {
+      "optional": true
+    },
+    "@duckmind/dm-tui": {
+      "optional": true
+    }
+  }
+}

package/extensions/dm-web-access/SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+Please report suspected vulnerabilities through GitHub private vulnerability reporting for this repository. Do not post exploit details, secrets, or proof-of-concept payloads in public issues or pull requests.
+
+If private vulnerability reporting is unavailable for your account or this repository, open a minimal public issue asking for a private contact path without including technical details.

package/extensions/dm-web-access/activity.js

@@ -0,0 +1,65 @@
+export class ActivityMonitor {
+  entries = [];
+  maxEntries = 10;
+  listeners = new Set;
+  rateLimitInfo = { used: 0, max: 10, oldestTimestamp: null, windowMs: 60000 };
+  nextId = 1;
+  logStart(partial) {
+    const id = `act-${this.nextId++}`;
+    const entry = {
+      ...partial,
+      id,
+      startTime: Date.now(),
+      status: null
+    };
+    this.entries.push(entry);
+    if (this.entries.length > this.maxEntries) {
+      this.entries.shift();
+    }
+    this.notify();
+    return id;
+  }
+  logComplete(id, status) {
+    const entry = this.entries.find((e) => e.id === id);
+    if (entry) {
+      entry.endTime = Date.now();
+      entry.status = status;
+      this.notify();
+    }
+  }
+  logError(id, error) {
+    const entry = this.entries.find((e) => e.id === id);
+    if (entry) {
+      entry.endTime = Date.now();
+      entry.error = error;
+      this.notify();
+    }
+  }
+  getEntries() {
+    return this.entries;
+  }
+  getRateLimitInfo() {
+    return this.rateLimitInfo;
+  }
+  updateRateLimit(info) {
+    this.rateLimitInfo = info;
+    this.notify();
+  }
+  onUpdate(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  clear() {
+    this.entries = [];
+    this.rateLimitInfo = { used: 0, max: 10, oldestTimestamp: null, windowMs: 60000 };
+    this.notify();
+  }
+  notify() {
+    for (const cb of this.listeners) {
+      try {
+        cb();
+      } catch {}
+    }
+  }
+}
+export const activityMonitor = new ActivityMonitor;

package/extensions/dm-web-access/anysearch.js

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { redactCredential, resolveCredential } from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const ANYSEARCH_API_URL = "https://api.anysearch.com/v1/search";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 30000;
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config in ${CONFIG_PATH}: expected a JSON object`);
+  }
+  cachedConfig = parsed;
+  return cachedConfig;
+}
+async function getApiKey(signal) {
+  return resolveCredential({
+    provider: "AnySearch",
+    configuredValue: loadConfig().anysearchApiKey,
+    environmentValue: process.env.ANYSEARCH_API_KEY,
+    signal
+  });
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function invalidResponse(message) {
+  return new Error(`AnySearch API returned invalid response: ${message}`);
+}
+function parseResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalidResponse("expected an object envelope");
+  }
+  const envelope = value;
+  if (envelope.code !== 0)
+    throw invalidResponse("expected code 0");
+  if (!envelope.data || typeof envelope.data !== "object" || Array.isArray(envelope.data)) {
+    throw invalidResponse("expected data object");
+  }
+  const data = envelope.data;
+  if (!Array.isArray(data.results))
+    throw invalidResponse("expected data.results array");
+  if (!data.metadata || typeof data.metadata !== "object" || Array.isArray(data.metadata)) {
+    throw invalidResponse("expected data.metadata object");
+  }
+  const results = [];
+  for (const [index, value] of data.results.entries()) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw invalidResponse(`expected data.results[${index}] object`);
+    }
+    const result = value;
+    const { title, url, snippet, content } = result;
+    if (typeof title !== "string")
+      throw invalidResponse(`expected data.results[${index}].title string`);
+    if (typeof url !== "string")
+      throw invalidResponse(`expected data.results[${index}].url string`);
+    if (typeof snippet !== "string")
+      throw invalidResponse(`expected data.results[${index}].snippet string`);
+    if (content !== undefined && content !== null && typeof content !== "string") {
+      throw invalidResponse(`expected data.results[${index}].content string`);
+    }
+    if (!url)
+      throw invalidResponse(`expected data.results[${index}].url to be non-empty`);
+    results.push({ title, url, snippet, content: typeof content === "string" ? content : "" });
+  }
+  return { code: 0, data: { results, metadata: data.metadata } };
+}
+function buildAnswer(results) {
+  return results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+}
+export function isAnySearchAvailable() {
+  return true;
+}
+export async function searchWithAnySearch(query, options = {}) {
+  const apiKey = await getApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const body = { query, max_results: numResults };
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  let response;
+  try {
+    response = await fetch(ANYSEARCH_API_URL, {
+      method: "POST",
+      headers: {
+        ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    const errorText = redactCredential(await response.text(), apiKey);
+    throw new Error(`AnySearch API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let rawData;
+  try {
+    rawData = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`AnySearch API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  let data;
+  try {
+    data = parseResponse(rawData);
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw err;
+  }
+  activityMonitor.logComplete(activityId, response.status);
+  const results = data.data.results.slice(0, numResults).map((result) => ({
+    title: result.title,
+    url: result.url,
+    snippet: result.snippet
+  }));
+  const mapped = { answer: buildAnswer(results), results };
+  if (options.includeContent) {
+    const inlineContent = data.data.results.slice(0, numResults).filter((result) => result.content.length > 0).map((result) => ({ url: result.url, title: result.title, content: result.content, error: null }));
+    if (inlineContent.length > 0)
+      mapped.inlineContent = inlineContent;
+  }
+  return mapped;
+}