@elizaos/prompts 2.0.0-alpha.98 → 2.0.3-beta.2

package/scripts/generate-action-docs.js

@@ -1,19 +1,10 @@
 #!/usr/bin/env node
-/**
- * Action/Provider/Evaluator Docs Generator
- *
- * Reads canonical specs from packages/prompts/specs/** and generates
- * language-native docs modules for:
- * - packages/typescript
- * - packages/python
- * - packages/rust
- *
- * This is intentionally dependency-free (no zod/yup) to keep builds lightweight.
- */
-
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { ensureDirectory, readJson } from "./file-utils.js";
+import { compressPromptDescription } from "./prompt-compression.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -23,14 +14,12 @@ const PROMPTS_ROOT = path.resolve(__dirname, "..");
 
 const ACTIONS_SPECS_DIR = path.join(PROMPTS_ROOT, "specs", "actions");
 const PROVIDERS_SPECS_DIR = path.join(PROMPTS_ROOT, "specs", "providers");
-const EVALUATORS_SPECS_DIR = path.join(PROMPTS_ROOT, "specs", "evaluators");
 
 const CORE_ACTIONS_SPEC_PATH = path.join(ACTIONS_SPECS_DIR, "core.json");
 const CORE_PROVIDERS_SPEC_PATH = path.join(PROVIDERS_SPECS_DIR, "core.json");
-const CORE_EVALUATORS_SPEC_PATH = path.join(EVALUATORS_SPECS_DIR, "core.json");
 
 /**
- * @typedef {"string" | "number" | "boolean" | "object" | "array"} JsonSchemaType
+ * @typedef {"string" | "number" | "integer" | "boolean" | "object" | "array"} JsonSchemaType
  */
 
 /**
@@ -55,6 +44,28 @@ function assertString(value, name) {
   }
 }
 
+/**
+ * @param {Record<string, unknown>} value
+ * @param {string} name
+ */
+function assertCompressedDescriptionAliases(value, name) {
+  if (value.descriptionCompressed !== undefined) {
+    assertString(value.descriptionCompressed, `${name}.descriptionCompressed`);
+  }
+  if (value.compressedDescription !== undefined) {
+    assertString(value.compressedDescription, `${name}.compressedDescription`);
+  }
+  if (
+    typeof value.descriptionCompressed === "string" &&
+    typeof value.compressedDescription === "string" &&
+    value.descriptionCompressed !== value.compressedDescription
+  ) {
+    throw new Error(
+      `${name}.descriptionCompressed and ${name}.compressedDescription must match when both are provided`,
+    );
+  }
+}
+
 /**
  * @param {unknown} value
  * @param {string} name
@@ -102,11 +113,25 @@ function assertExampleValuesArray(value, name) {
  */
 function assertParameterSchema(schema, name) {
   assertRecord(schema, name);
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+    for (let i = 0; i < schema.oneOf.length; i++) {
+      assertParameterSchema(schema.oneOf[i], `${name}.oneOf[${i}]`);
+    }
+    return;
+  }
+  if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+    for (let i = 0; i < schema.anyOf.length; i++) {
+      assertParameterSchema(schema.anyOf[i], `${name}.anyOf[${i}]`);
+    }
+    return;
+  }
   const t = schema.type;
   assertString(t, `${name}.type`);
-  if (!["string", "number", "boolean", "object", "array"].includes(t)) {
+  if (
+    !["string", "number", "integer", "boolean", "object", "array"].includes(t)
+  ) {
     throw new Error(
-      `${name}.type must be one of string|number|boolean|object|array`,
+      `${name}.type must be one of string|number|integer|boolean|object|array`,
     );
   }
   if (schema.enum !== undefined) {
@@ -144,6 +169,7 @@ function assertActionParameter(param, name) {
   assertRecord(param, name);
   assertString(param.name, `${name}.name`);
   assertString(param.description, `${name}.description`);
+  assertCompressedDescriptionAliases(param, name);
   if (param.required !== undefined) {
     assertBoolean(param.required, `${name}.required`);
   }
@@ -162,6 +188,7 @@ function assertActionDoc(action, name) {
   assertRecord(action, name);
   assertString(action.name, `${name}.name`);
   assertString(action.description, `${name}.description`);
+  assertCompressedDescriptionAliases(action, name);
   if (action.similes !== undefined) {
     assertArray(action.similes, `${name}.similes`);
     for (let i = 0; i < action.similes.length; i++) {
@@ -191,6 +218,7 @@ function assertProviderDoc(provider, name) {
   assertRecord(provider, name);
   assertString(provider.name, `${name}.name`);
   assertString(provider.description, `${name}.description`);
+  assertCompressedDescriptionAliases(provider, name);
   if (
     provider.position !== undefined &&
     typeof provider.position !== "number"
@@ -202,38 +230,6 @@ function assertProviderDoc(provider, name) {
   }
 }
 
-/**
- * @param {unknown} evaluator
- * @param {string} name
- * @returns {asserts evaluator is Record<string, unknown>}
- */
-function assertEvaluatorDoc(evaluator, name) {
-  assertRecord(evaluator, name);
-  assertString(evaluator.name, `${name}.name`);
-  assertString(evaluator.description, `${name}.description`);
-  if (evaluator.similes !== undefined) {
-    assertArray(evaluator.similes, `${name}.similes`);
-    for (let i = 0; i < evaluator.similes.length; i++) {
-      assertString(evaluator.similes[i], `${name}.similes[${i}]`);
-    }
-  }
-  if (evaluator.alwaysRun !== undefined) {
-    assertBoolean(evaluator.alwaysRun, `${name}.alwaysRun`);
-  }
-  if (evaluator.examples !== undefined) {
-    assertArray(evaluator.examples, `${name}.examples`);
-  }
-}
-
-/**
- * @param {string} filePath
- * @returns {unknown}
- */
-function readJson(filePath) {
-  const raw = fs.readFileSync(filePath, "utf-8");
-  return JSON.parse(raw);
-}
-
 /**
  * Recursively list .json files in a directory.
  * @param {string} rootDir
@@ -295,21 +291,6 @@ function parseProvidersSpec(root, label) {
   return { version: root.version, providers: root.providers };
 }
 
-/**
- * @param {unknown} root
- * @param {string} label
- * @returns {{ version: string, evaluators: unknown[] }}
- */
-function parseEvaluatorsSpec(root, label) {
-  assertRecord(root, label);
-  assertString(root.version, `${label}.version`);
-  assertArray(root.evaluators, `${label}.evaluators`);
-  for (let i = 0; i < root.evaluators.length; i++) {
-    assertEvaluatorDoc(root.evaluators[i], `${label}.evaluators[${i}]`);
-  }
-  return { version: root.version, evaluators: root.evaluators };
-}
-
 /**
  * @param {unknown[]} docs
  * @param {string} label
@@ -332,85 +313,53 @@ function assertUniqueNames(docs, label) {
 /**
  * @param {string} dir
  * @param {string} corePath
- * @param {"actions" | "providers" | "evaluators"} kind
+ * @param {"actions" | "providers"} kind
  * @returns {{ core: { version: string, items: unknown[] }, all: { version: string, items: unknown[] } }}
  */
 function loadSpecs(dir, corePath, kind) {
   if (!fs.existsSync(corePath)) {
-    return {
-      core: { version: "1.0.0", items: [] },
-      all: { version: "1.0.0", items: [] },
-    };
+    throw new Error(`Missing ${kind} core spec: ${corePath}`);
   }
 
   const coreRoot = readJson(corePath);
   const coreLabel = `${kind} core spec`;
-  let coreParsed;
-
-  if (kind === "actions") {
-    coreParsed = parseActionsSpec(coreRoot, coreLabel);
-  } else if (kind === "providers") {
-    coreParsed = parseProvidersSpec(coreRoot, coreLabel);
-  } else {
-    coreParsed = parseEvaluatorsSpec(coreRoot, coreLabel);
-  }
+  const coreParsed =
+    kind === "actions"
+      ? parseActionsSpec(coreRoot, coreLabel)
+      : parseProvidersSpec(coreRoot, coreLabel);
 
   const allFiles = listJsonFiles(dir).filter(
     (p) => path.resolve(p) !== path.resolve(corePath),
   );
   /** @type {unknown[]} */
   const merged = [
-    ...(kind === "actions"
-      ? coreParsed.actions
-      : kind === "providers"
-        ? coreParsed.providers
-        : coreParsed.evaluators),
+    ...(kind === "actions" ? coreParsed.actions : coreParsed.providers),
   ];
 
   for (const filePath of allFiles) {
     const root = readJson(filePath);
     const label = `${kind} spec (${path.relative(PROMPTS_ROOT, filePath)})`;
-    let parsed;
-
-    if (kind === "actions") {
-      parsed = parseActionsSpec(root, label);
-    } else if (kind === "providers") {
-      parsed = parseProvidersSpec(root, label);
-    } else {
-      parsed = parseEvaluatorsSpec(root, label);
-    }
+    const parsed =
+      kind === "actions"
+        ? parseActionsSpec(root, label)
+        : parseProvidersSpec(root, label);
 
     if (parsed.version !== coreParsed.version) {
       throw new Error(
         `${label}.version (${parsed.version}) must match core version (${coreParsed.version})`,
       );
     }
-    merged.push(
-      ...(kind === "actions"
-        ? parsed.actions
-        : kind === "providers"
-          ? parsed.providers
-          : parsed.evaluators),
-    );
+    merged.push(...(kind === "actions" ? parsed.actions : parsed.providers));
   }
 
   const itemsLabel =
-    kind === "actions"
-      ? "actions spec.actions"
-      : kind === "providers"
-        ? "providers spec.providers"
-        : "evaluators spec.evaluators";
+    kind === "actions" ? "actions spec.actions" : "providers spec.providers";
   assertUniqueNames(merged, itemsLabel);
 
   return {
     core: {
       version: coreParsed.version,
-      items:
-        kind === "actions"
-          ? coreParsed.actions
-          : kind === "providers"
-            ? coreParsed.providers
-            : coreParsed.evaluators,
+      items: kind === "actions" ? coreParsed.actions : coreParsed.providers,
     },
     all: {
       version: coreParsed.version,
@@ -420,48 +369,81 @@ function loadSpecs(dir, corePath, kind) {
 }
 
 /**
- * Ensures a directory exists, creating it and parent directories if necessary.
- * @param {string} dir - The directory path to ensure exists
- * @throws {Error} If the directory path is empty or whitespace-only
+ * @param {Record<string, unknown>} doc
+ * @returns {string | undefined}
  */
-function ensureDir(dir) {
-  if (!dir || dir.trim() === "") {
-    throw new Error("Directory path cannot be empty");
+function getCompressedAlias(doc) {
+  const preferred = doc.descriptionCompressed;
+  if (typeof preferred === "string" && preferred.trim()) {
+    return preferred;
   }
-  fs.mkdirSync(dir, { recursive: true });
+  const alias = doc.compressedDescription;
+  if (typeof alias === "string" && alias.trim()) {
+    return alias;
+  }
+  return undefined;
 }
 
 /**
- * @param {string} content
- * @returns {{ content: string, hashCount: number }}
+ * @param {Record<string, unknown>} doc
  */
-function escapeRustRawString(content) {
-  let hashCount = 1;
-  while (content.includes(`"${"#".repeat(hashCount)}`)) {
-    hashCount++;
+function normalizeCompressedDescription(doc) {
+  if (typeof doc.description !== "string") {
+    return;
   }
-  return { content, hashCount };
+  doc.descriptionCompressed =
+    getCompressedAlias(doc) ?? compressPromptDescription(doc.description);
 }
 
 /**
- * Escape a string for use in Python triple-quoted string.
- * JSON won't normally contain `"""` but we escape defensively.
- * @param {string} content
- * @returns {string}
+ * @param {Record<string, unknown>} action
  */
-function escapePythonTripleQuoted(content) {
-  return content.replace(/\\/g, "\\\\").replace(/"""/g, '\\"\\"\\"');
+function normalizeActionDoc(action) {
+  normalizeCompressedDescription(action);
+  if (!Array.isArray(action.parameters)) {
+    return;
+  }
+  for (const p of action.parameters) {
+    if (!p || typeof p !== "object") {
+      continue;
+    }
+    const param = /** @type {Record<string, unknown>} */ (p);
+    if (typeof param.description !== "string") {
+      continue;
+    }
+    normalizeCompressedDescription(param);
+  }
 }
 
-function generateTypeScript(actionsSpec, providersSpec, evaluatorsSpec) {
-  const outDir = path.join(
-    REPO_ROOT,
-    "packages",
-    "typescript",
-    "src",
-    "generated",
-  );
-  ensureDir(outDir);
+/**
+ * @param {Record<string, unknown>} provider
+ */
+function normalizeProviderDoc(provider) {
+  normalizeCompressedDescription(provider);
+}
+
+/**
+ * @param {{ core: { items: unknown[] }; all: { items: unknown[] } }} actionsSpec
+ * @param {{ core: { items: unknown[] }; all: { items: unknown[] } }} providersSpec
+ */
+function normalizeSpecsInPlace(actionsSpec, providersSpec) {
+  for (const action of actionsSpec.core.items) {
+    normalizeActionDoc(/** @type {Record<string, unknown>} */ (action));
+  }
+  for (const action of actionsSpec.all.items) {
+    normalizeActionDoc(/** @type {Record<string, unknown>} */ (action));
+  }
+  for (const p of providersSpec.core.items) {
+    normalizeProviderDoc(/** @type {Record<string, unknown>} */ (p));
+  }
+  for (const p of providersSpec.all.items) {
+    normalizeProviderDoc(/** @type {Record<string, unknown>} */ (p));
+  }
+}
+
+function generateTypeScript(actionsSpec, providersSpec) {
+  const outDir = path.join(REPO_ROOT, "packages", "core", "src", "generated");
+  ensureDirectory(outDir);
 
   const actionsJson = JSON.stringify(
     { version: actionsSpec.core.version, actions: actionsSpec.core.items },
@@ -486,37 +468,29 @@ function generateTypeScript(actionsSpec, providersSpec, evaluatorsSpec) {
     null,
     2,
   );
-  const evaluatorsJson = JSON.stringify(
-    {
-      version: evaluatorsSpec.core.version,
-      evaluators: evaluatorsSpec.core.items,
-    },
-    null,
-    2,
-  );
-  const evaluatorsAllJson = JSON.stringify(
-    {
-      version: evaluatorsSpec.all.version,
-      evaluators: evaluatorsSpec.all.items,
-    },
-    null,
-    2,
-  );
 
   const content = `/**
- * Auto-generated canonical action/provider/evaluator docs.
+ * Auto-generated action/provider docs.
  * DO NOT EDIT - Generated from packages/prompts/specs/**.
  */
 
-export type ActionDocParameterExampleValue = string | number | boolean | null;
+export type ActionDocParameterExampleValue =
+  | string
+  | number
+  | boolean
+  | null
+  | readonly ActionDocParameterExampleValue[]
+  | { readonly [key: string]: ActionDocParameterExampleValue };
 
 export type ActionDocParameterSchema = {
-  type: "string" | "number" | "boolean" | "object" | "array";
+  type: "string" | "number" | "integer" | "boolean" | "object" | "array";
   description?: string;
   default?: ActionDocParameterExampleValue;
   enum?: string[];
   properties?: Record<string, ActionDocParameterSchema>;
   items?: ActionDocParameterSchema;
+  oneOf?: ActionDocParameterSchema[];
+  anyOf?: ActionDocParameterSchema[];
   minimum?: number;
   maximum?: number;
   pattern?: string;
@@ -525,6 +499,8 @@ export type ActionDocParameterSchema = {
 export type ActionDocParameter = {
   name: string;
   description: string;
+  descriptionCompressed?: string;
+  compressedDescription?: string;
   required?: boolean;
   schema: ActionDocParameterSchema;
   examples?: readonly ActionDocParameterExampleValue[];
@@ -547,6 +523,8 @@ export type ActionDocExampleMessage = {
 export type ActionDoc = {
   name: string;
   description: string;
+  descriptionCompressed?: string;
+  compressedDescription?: string;
   similes?: readonly string[];
   parameters?: readonly ActionDocParameter[];
   examples?: readonly (readonly ActionDocExampleMessage[])[];
@@ -556,338 +534,39 @@ export type ActionDoc = {
 export type ProviderDoc = {
   name: string;
   description: string;
+  descriptionCompressed?: string;
+  compressedDescription?: string;
   position?: number;
   dynamic?: boolean;
 };
 
-export type EvaluatorDocMessageContent = {
-  text: string;
-  type?: string;
-};
-
-export type EvaluatorDocMessage = {
-  name: string;
-  content: EvaluatorDocMessageContent;
-};
-
-export type EvaluatorDocExample = {
-  prompt: string;
-  messages: readonly EvaluatorDocMessage[];
-  outcome: string;
-};
-
-export type EvaluatorDoc = {
-  name: string;
-  description: string;
-  similes?: readonly string[];
-  alwaysRun?: boolean;
-  examples?: readonly EvaluatorDocExample[];
-};
-
 export const coreActionsSpecVersion = ${JSON.stringify(actionsSpec.core.version)} as const;
 export const allActionsSpecVersion = ${JSON.stringify(actionsSpec.all.version)} as const;
 export const coreProvidersSpecVersion = ${JSON.stringify(providersSpec.core.version)} as const;
 export const allProvidersSpecVersion = ${JSON.stringify(providersSpec.all.version)} as const;
-export const coreEvaluatorsSpecVersion = ${JSON.stringify(evaluatorsSpec.core.version)} as const;
-export const allEvaluatorsSpecVersion = ${JSON.stringify(evaluatorsSpec.all.version)} as const;
 
 export const coreActionsSpec = ${actionsJson} as const satisfies { version: string; actions: readonly ActionDoc[] };
 export const allActionsSpec = ${actionsAllJson} as const satisfies { version: string; actions: readonly ActionDoc[] };
 export const coreProvidersSpec = ${providersJson} as const satisfies { version: string; providers: readonly ProviderDoc[] };
 export const allProvidersSpec = ${providersAllJson} as const satisfies { version: string; providers: readonly ProviderDoc[] };
-export const coreEvaluatorsSpec = ${evaluatorsJson} as const satisfies {
-  version: string;
-  evaluators: readonly EvaluatorDoc[];
-};
-export const allEvaluatorsSpec = ${evaluatorsAllJson} as const satisfies {
-  version: string;
-  evaluators: readonly EvaluatorDoc[];
-};
 
 export const coreActionDocs: readonly ActionDoc[] = coreActionsSpec.actions;
 export const allActionDocs: readonly ActionDoc[] = allActionsSpec.actions;
 export const coreProviderDocs: readonly ProviderDoc[] = coreProvidersSpec.providers;
 export const allProviderDocs: readonly ProviderDoc[] = allProvidersSpec.providers;
-export const coreEvaluatorDocs: readonly EvaluatorDoc[] = coreEvaluatorsSpec.evaluators;
-export const allEvaluatorDocs: readonly EvaluatorDoc[] = allEvaluatorsSpec.evaluators;
 `;
 
-  fs.writeFileSync(path.join(outDir, "action-docs.ts"), content);
-}
-
-function generatePython(actionsSpec, providersSpec, evaluatorsSpec) {
-  const outDir = path.join(
-    REPO_ROOT,
-    "packages",
-    "python",
-    "elizaos",
-    "generated",
-  );
-  ensureDir(outDir);
-
-  const initPath = path.join(outDir, "__init__.py");
-  if (!fs.existsSync(initPath)) {
-    fs.writeFileSync(initPath, '"""Auto-generated module package."""\n');
+  const actionDocsPath = path.join(outDir, "action-docs.ts");
+  fs.writeFileSync(actionDocsPath, content);
+  try {
+    execFileSync(
+      "bunx",
+      ["@biomejs/biome", "check", "--write", actionDocsPath],
+      { cwd: REPO_ROOT, stdio: "pipe" },
+    );
+  } catch (error) {
+    throw new Error(`Failed to format ${actionDocsPath}`, { cause: error });
   }
-
-  const actionsJson = JSON.stringify(
-    { version: actionsSpec.core.version, actions: actionsSpec.core.items },
-    null,
-    2,
-  );
-  const actionsAllJson = JSON.stringify(
-    { version: actionsSpec.all.version, actions: actionsSpec.all.items },
-    null,
-    2,
-  );
-  const providersJson = JSON.stringify(
-    {
-      version: providersSpec.core.version,
-      providers: providersSpec.core.items,
-    },
-    null,
-    2,
-  );
-  const providersAllJson = JSON.stringify(
-    { version: providersSpec.all.version, providers: providersSpec.all.items },
-    null,
-    2,
-  );
-  const evaluatorsJson = JSON.stringify(
-    {
-      version: evaluatorsSpec.core.version,
-      evaluators: evaluatorsSpec.core.items,
-    },
-    null,
-    2,
-  );
-  const evaluatorsAllJson = JSON.stringify(
-    {
-      version: evaluatorsSpec.all.version,
-      evaluators: evaluatorsSpec.all.items,
-    },
-    null,
-    2,
-  );
-
-  const content = `"""
-Auto-generated canonical action/provider/evaluator docs.
-DO NOT EDIT - Generated from packages/prompts/specs/**.
-"""
-
-from __future__ import annotations
-
-import json
-
-from typing import Literal, TypedDict
-
-
-JsonSchemaType = Literal["string", "number", "boolean", "object", "array"]
-ActionDocParameterExampleValue = str | int | float | bool | None
-
-
-class ActionDocParameterSchema(TypedDict, total=False):
-    type: JsonSchemaType
-    description: str
-    default: ActionDocParameterExampleValue
-    enum: list[str]
-    properties: dict[str, "ActionDocParameterSchema"]
-    items: "ActionDocParameterSchema"
-    minimum: float
-    maximum: float
-    pattern: str
-
-
-class ActionDocParameter(TypedDict, total=False):
-    name: str
-    description: str
-    required: bool
-    schema: ActionDocParameterSchema
-    examples: list[ActionDocParameterExampleValue]
-
-
-class ActionDocExampleCall(TypedDict, total=False):
-    user: str
-    actions: list[str]
-    params: dict[str, dict[str, ActionDocParameterExampleValue]]
-
-
-class ActionDocExampleMessage(TypedDict, total=False):
-    name: str
-    content: dict[str, object]
-
-
-class ActionDoc(TypedDict, total=False):
-    name: str
-    description: str
-    similes: list[str]
-    parameters: list[ActionDocParameter]
-    examples: list[list[ActionDocExampleMessage]]
-    exampleCalls: list[ActionDocExampleCall]
-
-
-class ProviderDoc(TypedDict, total=False):
-    name: str
-    description: str
-    position: int
-    dynamic: bool
-
-
-class EvaluatorDocMessageContent(TypedDict, total=False):
-    text: str
-    type: str
-
-
-class EvaluatorDocMessage(TypedDict):
-    name: str
-    content: EvaluatorDocMessageContent
-
-
-class EvaluatorDocExample(TypedDict):
-    prompt: str
-    messages: list[EvaluatorDocMessage]
-    outcome: str
-
-
-class EvaluatorDoc(TypedDict, total=False):
-    name: str
-    description: str
-    similes: list[str]
-    alwaysRun: bool
-    examples: list[EvaluatorDocExample]
-
-
-core_actions_spec_version: str = ${JSON.stringify(actionsSpec.core.version)}
-all_actions_spec_version: str = ${JSON.stringify(actionsSpec.all.version)}
-core_providers_spec_version: str = ${JSON.stringify(providersSpec.core.version)}
-all_providers_spec_version: str = ${JSON.stringify(providersSpec.all.version)}
-core_evaluators_spec_version: str = ${JSON.stringify(evaluatorsSpec.core.version)}
-all_evaluators_spec_version: str = ${JSON.stringify(evaluatorsSpec.all.version)}
-
-_CORE_ACTION_DOCS_JSON = """${escapePythonTripleQuoted(actionsJson)}"""
-_ALL_ACTION_DOCS_JSON = """${escapePythonTripleQuoted(actionsAllJson)}"""
-_CORE_PROVIDER_DOCS_JSON = """${escapePythonTripleQuoted(providersJson)}"""
-_ALL_PROVIDER_DOCS_JSON = """${escapePythonTripleQuoted(providersAllJson)}"""
-_CORE_EVALUATOR_DOCS_JSON = """${escapePythonTripleQuoted(evaluatorsJson)}"""
-_ALL_EVALUATOR_DOCS_JSON = """${escapePythonTripleQuoted(evaluatorsAllJson)}"""
-
-core_action_docs: dict[str, object] = json.loads(_CORE_ACTION_DOCS_JSON)
-all_action_docs: dict[str, object] = json.loads(_ALL_ACTION_DOCS_JSON)
-core_provider_docs: dict[str, object] = json.loads(_CORE_PROVIDER_DOCS_JSON)
-all_provider_docs: dict[str, object] = json.loads(_ALL_PROVIDER_DOCS_JSON)
-core_evaluator_docs: dict[str, object] = json.loads(_CORE_EVALUATOR_DOCS_JSON)
-all_evaluator_docs: dict[str, object] = json.loads(_ALL_EVALUATOR_DOCS_JSON)
-
-__all__ = [
-    "ActionDoc",
-    "ActionDocExampleCall",
-    "ActionDocExampleMessage",
-    "ActionDocParameter",
-    "ActionDocParameterSchema",
-    "ActionDocParameterExampleValue",
-    "ProviderDoc",
-    "EvaluatorDoc",
-    "EvaluatorDocExample",
-    "EvaluatorDocMessage",
-    "EvaluatorDocMessageContent",
-    "core_actions_spec_version",
-    "all_actions_spec_version",
-    "core_providers_spec_version",
-    "all_providers_spec_version",
-    "core_evaluators_spec_version",
-    "all_evaluators_spec_version",
-    "core_action_docs",
-    "all_action_docs",
-    "core_provider_docs",
-    "all_provider_docs",
-    "core_evaluator_docs",
-    "all_evaluator_docs",
-]
-`;
-
-  fs.writeFileSync(path.join(outDir, "action_docs.py"), content);
-}
-
-function generateRust(actionsSpec, providersSpec, evaluatorsSpec) {
-  const outDir = path.join(REPO_ROOT, "packages", "rust", "src", "generated");
-  ensureDir(outDir);
-
-  const actionsJson = JSON.stringify(
-    { version: actionsSpec.core.version, actions: actionsSpec.core.items },
-    null,
-    2,
-  );
-  const actionsAllJson = JSON.stringify(
-    { version: actionsSpec.all.version, actions: actionsSpec.all.items },
-    null,
-    2,
-  );
-  const providersJson = JSON.stringify(
-    {
-      version: providersSpec.core.version,
-      providers: providersSpec.core.items,
-    },
-    null,
-    2,
-  );
-  const providersAllJson = JSON.stringify(
-    { version: providersSpec.all.version, providers: providersSpec.all.items },
-    null,
-    2,
-  );
-  const evaluatorsJson = JSON.stringify(
-    {
-      version: evaluatorsSpec.core.version,
-      evaluators: evaluatorsSpec.core.items,
-    },
-    null,
-    2,
-  );
-  const evaluatorsAllJson = JSON.stringify(
-    {
-      version: evaluatorsSpec.all.version,
-      evaluators: evaluatorsSpec.all.items,
-    },
-    null,
-    2,
-  );
-
-  const { content: actionsContent, hashCount: actionsHashCount } =
-    escapeRustRawString(actionsJson);
-  const { content: actionsAllContent, hashCount: actionsAllHashCount } =
-    escapeRustRawString(actionsAllJson);
-  const { content: providersContent, hashCount: providersHashCount } =
-    escapeRustRawString(providersJson);
-  const { content: providersAllContent, hashCount: providersAllHashCount } =
-    escapeRustRawString(providersAllJson);
-  const { content: evalContent, hashCount: evalHashCount } =
-    escapeRustRawString(evaluatorsJson);
-  const { content: evalAllContent, hashCount: evalAllHashCount } =
-    escapeRustRawString(evaluatorsAllJson);
-
-  const actionsDelim = "#".repeat(actionsHashCount);
-  const actionsAllDelim = "#".repeat(actionsAllHashCount);
-  const providersDelim = "#".repeat(providersHashCount);
-  const providersAllDelim = "#".repeat(providersAllHashCount);
-  const evalDelim = "#".repeat(evalHashCount);
-  const evalAllDelim = "#".repeat(evalAllHashCount);
-
-  const content = `//! Auto-generated canonical action/provider/evaluator docs.
-//! DO NOT EDIT - Generated from packages/prompts/specs/**.
-
-pub const CORE_ACTION_DOCS_JSON: &str = r${actionsDelim}"${actionsContent}"${actionsDelim};
-pub const ALL_ACTION_DOCS_JSON: &str = r${actionsAllDelim}"${actionsAllContent}"${actionsAllDelim};
-pub const CORE_PROVIDER_DOCS_JSON: &str = r${providersDelim}"${providersContent}"${providersDelim};
-pub const ALL_PROVIDER_DOCS_JSON: &str = r${providersAllDelim}"${providersAllContent}"${providersAllDelim};
-pub const CORE_EVALUATOR_DOCS_JSON: &str = r${evalDelim}"${evalContent}"${evalDelim};
-pub const ALL_EVALUATOR_DOCS_JSON: &str = r${evalAllDelim}"${evalAllContent}"${evalAllDelim};
-`;
-
-  fs.writeFileSync(path.join(outDir, "action_docs.rs"), content);
-
-  const modPath = path.join(outDir, "mod.rs");
-  const modContent = `//! Auto-generated docs module.\n\npub mod action_docs;\n`;
-  fs.writeFileSync(modPath, modContent);
 }
 
 function main() {
@@ -901,17 +580,12 @@ function main() {
     CORE_PROVIDERS_SPEC_PATH,
     "providers",
   );
-  const evaluatorsSpec = loadSpecs(
-    EVALUATORS_SPECS_DIR,
-    CORE_EVALUATORS_SPEC_PATH,
-    "evaluators",
-  );
 
-  generateTypeScript(actionsSpec, providersSpec, evaluatorsSpec);
-  generatePython(actionsSpec, providersSpec, evaluatorsSpec);
-  generateRust(actionsSpec, providersSpec, evaluatorsSpec);
+  normalizeSpecsInPlace(actionsSpec, providersSpec);
+
+  generateTypeScript(actionsSpec, providersSpec);
 
-  console.log("Generated action/provider/evaluator docs.");
+  console.log("Generated action/provider docs.");
 }
 
 main();