#!/usr/bin/env bun

/**

* Projects the executable tool registry down to its serializable metadata.

*

* `apps/sim/tools/registry.ts` is a ~9,000-line barrel importing all 4,300+

* tools. Each `ToolConfig` mixes plain data (`params`, `outputs`, `name`) with

* closures (`request.headers`, `transformResponse`, `directExecution`,

* `postProcess`), and it is those closures — and the SDK clients and API

* helpers they reach — that make the barrel cost ~4,700 modules to compile.

*

* No client-reachable caller needs a closure. They need `outputs` (block output

* inference), `params` (serialization and the tool-input panel), or merely

* whether an id exists. So this script emits that data on its own, letting those

* callers read tool metadata without pulling the registry.

*

* Two artifacts rather than one, because `outputs` is ~4 MB of the ~6 MB and has

* a single consumer — keeping it separate means callers that only need `params`

* or an id check don't pay for it:

*

* tools/generated/tool-ids.ts every registered tool id

* tools/generated/tool-metadata.ts id -> { name, description, version, params, oauth }

* tools/generated/tool-outputs.ts id -> outputs

*

* Ids are their own artifact because resolving a possibly-unversioned tool name

* needs only the key set, and an existence check needs nothing more — so those

* callers load ~100 KB instead of ~4 MB.

*

* Each artifact holds its data as one JSON string parsed at runtime — see

* `serialize()` for why an imported `.json` or an object literal is not viable

* at this size.

*

* Usage:

* bun run scripts/sync-tool-metadata.ts # write artifacts

* bun run scripts/sync-tool-metadata.ts --check # fail (exit 1) if stale

*/

import { mkdir, readFile, writeFile } from 'node:fs/promises'

import { dirname, resolve } from 'node:path'

import { fileURLToPath } from 'node:url'

import { tools } from '../apps/sim/tools/registry'

import { hasToolId } from '../apps/sim/tools/tool-ids'

import type { ToolConfig } from '../apps/sim/tools/types'

import { getTool } from '../apps/sim/tools/utils'

const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))

const ROOT = resolve(SCRIPT_DIR, '..')

const GENERATED_DIR = resolve(ROOT, 'apps/sim/tools/generated')

const IDS_PATH = resolve(GENERATED_DIR, 'tool-ids.ts')

const METADATA_PATH = resolve(GENERATED_DIR, 'tool-metadata.ts')

const OUTPUTS_PATH = resolve(GENERATED_DIR, 'tool-outputs.ts')

/**

* Fields copied into `tool-metadata.ts`. Every one must be plain data.

*

* Deliberately excluded: `request`, `transformResponse`, `directExecution`,

* `postProcess` (closures, and the whole reason the registry is expensive);

* `hosting` and `schemaEnrichment` (contain predicates/`enrichSchema`, and are

* only consumed server-side); `outputs` (emitted separately).

*/

const METADATA_FIELDS = ['name', 'description', 'version', 'params', 'oauth'] as const

type ToolRecord = Record<string, ToolConfig>

/**

* Recursively locates any function value, which must never reach the artifacts.

*

* Unbounded in depth on purpose: param and output schemas nest arbitrarily, and

* a depth cap would let a deeply-nested closure through — `JSON.stringify` drops

* it silently, so the artifact would ship an incomplete schema while generation

* reported success. `seen` guards the cycles that removing the cap exposes.

*/

function findFunctionPaths(

value: unknown,

path: string,

found: string[],

seen = new WeakSet<object>()

): void {

if (found.length >= 10 || value == null) return

if (typeof value === 'function') {

found.push(path)

return

}

if (typeof value !== 'object') return

if (seen.has(value as object)) return

seen.add(value as object)

if (Array.isArray(value)) {

value.forEach((item, i) => findFunctionPaths(item, `${path}[${i}]`, found, seen))

return

}

for (const [key, item] of Object.entries(value as object)) {

findFunctionPaths(item, `${path}.${key}`, found, seen)

}

}

/**

* Drops empty param entries so consumers may iterate params unguarded.

*

* The registry contains one (`stt_deepgram_v2`), which crashes any caller that

* reads `param.type` while iterating. That entry is `undefined`, which

* `JSON.stringify` would drop anyway; this guard additionally covers an explicit

* `null` — which serializes faithfully and would reach consumers — and surfaces

* either case as a warning rather than silently.

*/

function normalizeParams(toolId: string, params: ToolConfig['params'] | undefined) {

const normalized: Record<string, unknown> = {}

let dropped = 0

for (const [paramId, config] of Object.entries(params ?? {})) {

if (config == null) {

dropped++

continue

}

normalized[paramId] = config

}

if (dropped > 0) {

console.warn(`[tool-metadata] ${toolId}: dropped ${dropped} empty param entr(y/ies)`)

}

return normalized

}

function build(registry: ToolRecord) {

const metadata: Record<string, unknown> = {}

const outputs: Record<string, unknown> = {}

// Sorted so the artifacts are stable across runs regardless of registry order.

for (const toolId of Object.keys(registry).sort()) {

const tool = registry[toolId] as ToolConfig & Record<string, unknown>

if (!tool) continue

const entry: Record<string, unknown> = { id: tool.id ?? toolId }

for (const field of METADATA_FIELDS) {

if (field === 'params') {

entry.params = normalizeParams(toolId, tool.params)

} else if (tool[field] !== undefined) {

entry[field] = tool[field]

}

}

metadata[toolId] = entry

if (tool.outputs !== undefined) outputs[toolId] = tool.outputs

}

const offenders: string[] = []

findFunctionPaths(metadata, 'metadata', offenders)

findFunctionPaths(outputs, 'outputs', offenders)

if (offenders.length > 0) {

throw new Error(

`Refusing to emit tool metadata: found non-serializable values at:\n ${offenders.join('\n ')}\n` +

`Add the offending field to the exclusion list in ${'scripts/sync-tool-metadata.ts'}.`

)

}

return {

ids: serializeValue(

Object.keys(metadata),

'toolIds',

'/** Every registered tool id, including versioned variants. */',

'string[]'

),

metadata: serialize(

metadata,

'toolMetadata',

'/** Serializable metadata for every built-in tool, keyed by tool id. */'

),

outputs: serialize(

outputs,

'toolOutputs',

'/** Declared output shapes for every built-in tool, keyed by tool id. */'

),

toolCount: Object.keys(metadata).length,

}

}

/**

* Escapes a JSON document into a single-quoted JavaScript string literal.

*

* Single quotes rather than double: JSON is dense with `"`, which would need

* escaping inside a double-quoted literal and inflates the file by ~90%.

*/

function toJsStringLiteral(json: string): string {

const escaped = json

.replace(/\\/g, '\\\\')

.replace(/'/g, "\\'")

.replace(/\n/g, '\\n')

.replace(/\r/g, '\\r')

// Valid raw inside a JSON string, but line terminators in a JS literal.

.replace(/\u2028/g, '\\u2028')

.replace(/\u2029/g, '\\u2029')

return `'${escaped}'`

}

/**

* Emits the data as a string parsed at runtime, rather than as an object

* literal or an imported `.json`.

*

* Both of the obvious alternatives are unusable at this size. A `.json` import

* (with `resolveJsonModule`, which this repo enables) makes TypeScript infer a

* literal type for all 4,300+ entries: it took `tsc --noEmit` from **12.6s to

* 8m07s**, a 38x regression, and an ambient `declare module` does not

* short-circuit it. A generated object literal costs the same, since it is the

* same inference work.

*

* A single string literal is one cheap token for the compiler and the bundler,

* and `JSON.parse` on a large payload is faster at runtime than evaluating the

* equivalent object literal.

*

* The trade-off is that these files diff as one line. That is acceptable for a

* generated artifact nothing reads by eye and CI verifies wholesale.

*/

function serialize(entries: Record<string, unknown>, exportName: string, doc: string): string {

return serializeValue(entries, exportName, doc, 'Record<string, unknown>')

}

function serializeValue(value: unknown, exportName: string, doc: string, type: string): string {

const literal = toJsStringLiteral(JSON.stringify(value))

return `// Generated by scripts/sync-tool-metadata.ts — do not edit.

// Regenerate with: bun run tool-metadata:generate

${doc}

const ${exportName}: ${type} = JSON.parse(

${literal}

)

export default ${exportName}

`

}

/**

* Asserts the two tool-id resolvers agree.

*

* `@/tools/utils` resolves against the live registry; `@/tools/tool-ids` against

* the generated id list. Both exist deliberately — the registry-backed one keeps

* a newly-added tool resolvable before regeneration, the list-backed one lets

* client code resolve without importing 4,300 tools. Nothing structurally keeps

* the two in step, so it is checked here rather than left to trust.

*

* Runs only after the staleness check passes, since a stale id list would

* otherwise report a divergence that is really just a missing regeneration. It

* cannot live in a vitest suite: `vitest.setup.ts` globally mocks

* `@/tools/registry` to an empty map, so `getTool` resolves nothing there.

*/

function assertResolverParity() {

const ids = Object.keys(tools)

const probes = new Set([...ids, ...ids.map((id) => id.replace(/_v\d+$/, '')), '__not_a_tool__'])

const divergent: string[] = []

for (const probe of probes) {

if (Boolean(getTool(probe)) !== hasToolId(probe)) divergent.push(probe)

}

if (divergent.length > 0) {

throw new Error(

`Tool id resolvers disagree on ${divergent.length} of ${probes.size} names ` +

`(e.g. ${divergent.slice(0, 5).join(', ')}).\n` +

'resolveToolId in apps/sim/tools/utils.ts and apps/sim/tools/tool-ids.ts have drifted.'

)

}

}

async function main() {

const checkOnly = process.argv.includes('--check')

const { ids, metadata, outputs, toolCount } = build(tools as ToolRecord)

if (checkOnly) {

const [existingIds, existingMetadata, existingOutputs] = await Promise.all([

readFile(IDS_PATH, 'utf8').catch(() => null),

readFile(METADATA_PATH, 'utf8').catch(() => null),

readFile(OUTPUTS_PATH, 'utf8').catch(() => null),

])

if (existingIds !== ids || existingMetadata !== metadata || existingOutputs !== outputs) {

throw new Error('Generated tool metadata is stale. Run: bun run tool-metadata:generate')

}

assertResolverParity()

console.log(`✓ tool metadata in sync (${toolCount} tools), resolvers agree`)

return

}

await mkdir(GENERATED_DIR, { recursive: true })

await Promise.all([

writeFile(IDS_PATH, ids, 'utf8'),

writeFile(METADATA_PATH, metadata, 'utf8'),

writeFile(OUTPUTS_PATH, outputs, 'utf8'),

])

console.log(`✓ wrote tool metadata for ${toolCount} tools`)

}

await main()