Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

3.0 KB
Raw Blame
import { readFileSync } from 'node:fs';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { HarnessError } from './errors.mjs';

const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');

export const BROWSER_GRANT_TOOLKITS = [
  { exportPrefix: 'GMAIL', slug: 'gmail' },
  { slug: 'googledrive' },
  { exportPrefix: 'GITHUB', slug: 'github' },
  { exportPrefix: 'SLACK', slug: 'slack' },
];

export const DEMO_TOOLKIT = {
  exportPrefix: 'APIKEY',
  slug: 'serpapi',
  demoValue: 'examples-demo-key',
};

const parseCsv = value =>
  value
    ? value
        .split(',')
        .map(part => part.trim())
        .filter(Boolean)
    : [];

const toolkitForId = id => {
  for (const toolkit of [...BROWSER_GRANT_TOOLKITS, DEMO_TOOLKIT]) {
    if (toolkit.exportPrefix && id.startsWith(`COMPOSIO_EXAMPLES_${toolkit.exportPrefix}_`)) {
      return toolkit.slug;
    }
  }
  return undefined;
};

export const entryToolkits = entry => {
  const toolkits = new Set(entry.toolkits ?? []);
  for (const id of entry.ids ?? []) {
    const toolkit = toolkitForId(id);
    if (toolkit) toolkits.add(toolkit);
  }
  return [...toolkits];
};

export const validateManifestEntries = entries => {
  for (const entry of entries) {
    if (!entry.id || !entry.lang || !entry.file || !entry.tier) {
      throw new HarnessError(`manifest entry missing required fields: ${JSON.stringify(entry)}`);
    }
    if (entry.lang === 'ts' && entry.tier !== 'X' && !entry.pkg) {
      throw new HarnessError(`ts entry ${entry.id} missing pkg`);
    }
    if (entry.tier === '3' && !entry.readiness) {
      throw new HarnessError(`tier-3 entry ${entry.id} missing readiness regex`);
    }
  }
  return entries;
};

export const loadManifest = () =>
  validateManifestEntries(
    JSON.parse(readFileSync(join(ROOT, 'examples-manifest.json'), 'utf8')).entries
  );

export const selectManifestEntries = (
  entries,
  { lang, ids, tiers = '1,2,3', excludeToolkits } = {}
) => {
  const selectedIds = new Set(parseCsv(ids));
  const selectedTiers = new Set(parseCsv(tiers));
  const excludedToolkitSet = new Set(parseCsv(excludeToolkits));
  const eligibleEntries = entries.filter(
    entry =>
      entry.tier !== 'X' &&
      selectedTiers.has(entry.tier) &&
      (!lang || entry.lang === lang) &&
      (selectedIds.size === 0 || selectedIds.has(entry.id))
  );
  const excludedEntries = eligibleEntries.filter(entry =>
    entryToolkits(entry).some(toolkit => excludedToolkitSet.has(toolkit))
  );
  const excludedIds = new Set(excludedEntries.map(entry => entry.id));

  return {
    entries: eligibleEntries.filter(entry => !excludedIds.has(entry.id)),
    excludedEntries,
    excludedToolkits: [...excludedToolkitSet],
  };
};

export const requiredBrowserGrantToolkits = entries =>
  BROWSER_GRANT_TOOLKITS.filter(toolkit =>
    entries.some(entry => entryToolkits(entry).includes(toolkit.slug))
  );

export const requiresDemoToolkit = entries =>
  entries.some(entry => entryToolkits(entry).includes(DEMO_TOOLKIT.slug));