@axintai/compiler 0.2.1 → 0.3.0

package/dist/mcp/index.js

@@ -51,6 +51,10 @@ function irTypeToSwift(type) {
       return `${irTypeToSwift(type.innerType)}?`;
     case "entity":
       return type.entityName;
+    case "entityQuery":
+      return `${type.entityName}Query`;
+    case "dynamicOptions":
+      return `[DynamicOptionsResult<${irTypeToSwift(type.valueType)}>]`;
     case "enum":
       return type.name;
   }
@@ -66,6 +70,9 @@ function parseIntentSource(source, filePath = "<stdin>") {
     // setParentNodes
     ts.ScriptKind.TS
   );
+  const entities = findDefineEntityCalls(sourceFile).map(
+    (call) => parseEntityDefinition(call, filePath, sourceFile)
+  );
   const defineIntentCall = findDefineIntentCall(sourceFile);
   if (!defineIntentCall) {
     throw new ParserError(
@@ -128,6 +135,10 @@ function parseIntentSource(source, filePath = "<stdin>") {
   const entitlements = readStringArray(entitlementsNode);
   const infoPlistNode = props.get("infoPlistKeys");
   const infoPlistKeys = readStringRecord(infoPlistNode);
+  const donateOnPerformNode = props.get("donateOnPerform");
+  const donateOnPerform = readBooleanLiteral(donateOnPerformNode);
+  const customResultTypeNode = props.get("customResultType");
+  const customResultType = readStringLiteral(customResultTypeNode);
   return {
     name,
     title,
@@ -139,7 +150,10 @@ function parseIntentSource(source, filePath = "<stdin>") {
     sourceFile: filePath,
     entitlements: entitlements.length > 0 ? entitlements : void 0,
     infoPlistKeys: Object.keys(infoPlistKeys).length > 0 ? infoPlistKeys : void 0,
-    isDiscoverable: isDiscoverable ?? void 0
+    isDiscoverable: isDiscoverable ?? void 0,
+    entities: entities.length > 0 ? entities : void 0,
+    donateOnPerform: donateOnPerform ?? void 0,
+    customResultType: customResultType ?? void 0
   };
 }
 function findDefineIntentCall(node) {
@@ -155,6 +169,18 @@ function findDefineIntentCall(node) {
   visit(node);
   return found;
 }
+function findDefineEntityCalls(node) {
+  const found = [];
+  const visit = (n) => {
+    if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === "defineEntity") {
+      found.push(n);
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
 function propertyMap(obj) {
   const map = /* @__PURE__ */ new Map();
   for (const prop of obj.properties) {
@@ -208,6 +234,77 @@ function readStringRecord(node) {
   }
   return rec;
 }
+function parseEntityDefinition(call, filePath, sourceFile) {
+  const arg = call.arguments[0];
+  if (!arg || !ts.isObjectLiteralExpression(arg)) {
+    throw new ParserError(
+      "AX015",
+      "defineEntity() must be called with an object literal",
+      filePath,
+      posOf(sourceFile, call),
+      "Pass an object: defineEntity({ name, display, properties, query })"
+    );
+  }
+  const props = propertyMap(arg);
+  const name = readStringLiteral(props.get("name"));
+  if (!name) {
+    throw new ParserError(
+      "AX016",
+      "Entity definition missing required field: name",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add a name field: name: "Task"'
+    );
+  }
+  const displayNode = props.get("display");
+  if (!displayNode || !ts.isObjectLiteralExpression(displayNode)) {
+    throw new ParserError(
+      "AX017",
+      "Entity definition missing required field: display",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add display field: display: { title: "name", subtitle: "status" }'
+    );
+  }
+  const displayProps = propertyMap(displayNode);
+  const displayRepresentation = {
+    title: readStringLiteral(displayProps.get("title")) || "name",
+    subtitle: readStringLiteral(displayProps.get("subtitle")) || void 0,
+    image: readStringLiteral(displayProps.get("image")) || void 0
+  };
+  const propertiesNode = props.get("properties");
+  const properties = propertiesNode ? extractParameters(propertiesNode, filePath, sourceFile) : [];
+  const queryTypeNode = props.get("query");
+  const queryTypeStr = readStringLiteral(queryTypeNode);
+  const queryType = validateQueryType(queryTypeStr, filePath, sourceFile, queryTypeNode);
+  return {
+    name,
+    displayRepresentation,
+    properties,
+    queryType
+  };
+}
+function validateQueryType(value, filePath, sourceFile, node) {
+  if (!value) {
+    throw new ParserError(
+      "AX018",
+      "Entity definition missing required field: query",
+      filePath,
+      node ? posOf(sourceFile, node) : void 0,
+      'Add query field: query: "string" (or "all", "id", "property")'
+    );
+  }
+  const valid = ["all", "id", "string", "property"];
+  if (!valid.includes(value)) {
+    throw new ParserError(
+      "AX019",
+      `Invalid query type: "${value}". Must be one of: all, id, string, property`,
+      filePath,
+      node ? posOf(sourceFile, node) : void 0
+    );
+  }
+  return value;
+}
 function extractParameters(node, filePath, sourceFile) {
   if (!ts.isObjectLiteralExpression(node)) {
     throw new ParserError(
@@ -223,20 +320,20 @@ function extractParameters(node, filePath, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) continue;
     const paramName = propertyKeyName(prop.name);
     if (!paramName) continue;
-    const { typeName, description, configObject } = extractParamCall(
+    const { typeName, description, configObject, callExpr } = extractParamCall(
       prop.initializer,
       filePath,
       sourceFile
     );
-    const resolvedType = resolveParamType(typeName, filePath, sourceFile, prop);
+    const resolvedType = resolveParamType(typeName, filePath, sourceFile, prop, callExpr);
     const isOptional = configObject ? readBooleanLiteral(configObject.get("required")) === false : false;
     const defaultExpr = configObject?.get("default");
     const defaultValue = defaultExpr ? evaluateLiteral(defaultExpr) : void 0;
     const titleFromConfig = configObject ? readStringLiteral(configObject.get("title")) : null;
     const irType = isOptional ? {
       kind: "optional",
-      innerType: { kind: "primitive", value: resolvedType }
-    } : { kind: "primitive", value: resolvedType };
+      innerType: resolvedType
+    } : resolvedType;
     params.push({
       name: paramName,
       type: irType,
@@ -268,34 +365,98 @@ function extractParamCall(expr, filePath, sourceFile) {
     );
   }
   const typeName = expr.expression.name.text;
-  const descriptionArg = expr.arguments[0];
-  const configArg = expr.arguments[1];
+  let descriptionArg;
+  let configArg;
+  if (typeName === "entity" && expr.arguments.length >= 2) {
+    descriptionArg = expr.arguments[1];
+    configArg = expr.arguments[2];
+  } else if (typeName === "dynamicOptions" && expr.arguments.length >= 3) {
+    descriptionArg = expr.arguments[2];
+    configArg = expr.arguments[3];
+  } else {
+    descriptionArg = expr.arguments[0];
+    configArg = expr.arguments[1];
+  }
   const description = descriptionArg ? readStringLiteral(descriptionArg) : null;
   if (description === null) {
     throw new ParserError(
       "AX008",
-      `param.${typeName}() requires a string description as the first argument`,
+      `param.${typeName}() requires a string description`,
       filePath,
       posOf(sourceFile, expr),
       `Example: param.${typeName}("Human-readable description")`
     );
   }
   const configObject = configArg && ts.isObjectLiteralExpression(configArg) ? propertyMap(configArg) : null;
-  return { typeName, description, configObject };
+  return { typeName, description, configObject, callExpr: expr };
 }
-function resolveParamType(typeName, filePath, sourceFile, node) {
+function resolveParamType(typeName, filePath, sourceFile, node, callExpr) {
   if (PARAM_TYPES.has(typeName)) {
-    return typeName;
+    return { kind: "primitive", value: typeName };
   }
   if (typeName in LEGACY_PARAM_ALIASES) {
-    return LEGACY_PARAM_ALIASES[typeName];
+    return {
+      kind: "primitive",
+      value: LEGACY_PARAM_ALIASES[typeName]
+    };
+  }
+  if (typeName === "entity") {
+    if (!callExpr || callExpr.arguments.length === 0) {
+      throw new ParserError(
+        "AX020",
+        "param.entity() requires the entity name as the first argument",
+        filePath,
+        posOf(sourceFile, node),
+        'Example: param.entity("Task", "Reference an entity")'
+      );
+    }
+    const entityName = readStringLiteral(callExpr.arguments[0]);
+    if (!entityName) {
+      throw new ParserError(
+        "AX021",
+        "param.entity() requires a string entity name",
+        filePath,
+        posOf(sourceFile, node)
+      );
+    }
+    return {
+      kind: "entity",
+      entityName,
+      properties: []
+    };
+  }
+  if (typeName === "dynamicOptions") {
+    if (!callExpr || callExpr.arguments.length < 2) {
+      throw new ParserError(
+        "AX022",
+        "param.dynamicOptions() requires (providerName, paramType)",
+        filePath,
+        posOf(sourceFile, node),
+        'Example: param.dynamicOptions("PlaylistProvider", param.string(...))'
+      );
+    }
+    const providerName = readStringLiteral(callExpr.arguments[0]);
+    if (!providerName) {
+      throw new ParserError(
+        "AX023",
+        "param.dynamicOptions() provider name must be a string",
+        filePath,
+        posOf(sourceFile, node)
+      );
+    }
+    const valueType = { kind: "primitive", value: "string" };
+    return {
+      kind: "dynamicOptions",
+      valueType,
+      providerName
+    };
   }
   throw new ParserError(
     "AX005",
     `Unknown param type: param.${typeName}`,
     filePath,
     posOf(sourceFile, node),
-    `Supported types: ${[...PARAM_TYPES].join(", ")}`
+    `Supported types: ${[...PARAM_TYPES].join(", ")}, entity, dynamicOptions`
   );
 }
 function evaluateLiteral(node) {
@@ -413,6 +574,14 @@ function generateSwift(intent) {
   lines.push(`import AppIntents`);
   lines.push(`import Foundation`);
   lines.push(``);
+  if (intent.entities && intent.entities.length > 0) {
+    for (const entity of intent.entities) {
+      lines.push(generateEntity(entity));
+      lines.push(``);
+      lines.push(generateEntityQuery(entity));
+      lines.push(``);
+    }
+  }
   lines.push(`struct ${intent.name}Intent: AppIntent {`);
   lines.push(
     `    static let title: LocalizedStringResource = "${escapeSwiftString(intent.title)}"`
@@ -430,27 +599,109 @@ function generateSwift(intent) {
   if (intent.parameters.length > 0) {
     lines.push(``);
   }
-  const returnTypeSignature = generateReturnSignature(intent.returnType);
+  const returnTypeSignature = generateReturnSignature(
+    intent.returnType,
+    intent.customResultType
+  );
   lines.push(`    func perform() async throws -> ${returnTypeSignature} {`);
   lines.push(`        // TODO: Implement your intent logic here.`);
   if (intent.parameters.length > 0) {
     const paramList = intent.parameters.map((p) => `\\(${p.name})`).join(", ");
     lines.push(`        // Parameters available: ${paramList}`);
   }
-  lines.push(generatePerformReturn(intent.returnType));
+  if (intent.donateOnPerform) {
+    lines.push(`        `);
+    lines.push(`        // Donate this intent to Siri and Spotlight`);
+    lines.push(`        try? await IntentDonationManager.shared.donate(intent: self)`);
+  }
+  lines.push(generatePerformReturn(intent.returnType, intent.customResultType));
   lines.push(`    }`);
   lines.push(`}`);
   lines.push(``);
   return lines.join("\n");
 }
+function generateEntity(entity) {
+  const lines = [];
+  const propertyNames = new Set(entity.properties.map((p) => p.name));
+  lines.push(`struct ${entity.name}: AppEntity {`);
+  lines.push(`    static var defaultQuery = ${entity.name}Query()`);
+  lines.push(``);
+  const hasId = propertyNames.has("id");
+  if (!hasId) {
+    lines.push(`    var id: String`);
+  }
+  for (const prop of entity.properties) {
+    const swiftType = irTypeToSwift(prop.type);
+    lines.push(`    var ${prop.name}: ${swiftType}`);
+  }
+  lines.push(``);
+  lines.push(
+    `    static let typeDisplayRepresentation: TypeDisplayRepresentation = TypeDisplayRepresentation(`
+  );
+  lines.push(
+    `        name: LocalizedStringResource("${escapeSwiftString(entity.name)}")`
+  );
+  lines.push(`    )`);
+  lines.push(``);
+  lines.push(`    var displayRepresentation: DisplayRepresentation {`);
+  lines.push(`        DisplayRepresentation(`);
+  lines.push(
+    `            title: "\\(${entity.displayRepresentation.title})"${entity.displayRepresentation.subtitle || entity.displayRepresentation.image ? "," : ""}`
+  );
+  if (entity.displayRepresentation.subtitle) {
+    const hasImage = !!entity.displayRepresentation.image;
+    lines.push(
+      `            subtitle: "\\(${entity.displayRepresentation.subtitle})"${hasImage ? "," : ""}`
+    );
+  }
+  if (entity.displayRepresentation.image) {
+    lines.push(
+      `            image: .init(systemName: "${escapeSwiftString(entity.displayRepresentation.image)}")`
+    );
+  }
+  lines.push(`        )`);
+  lines.push(`    }`);
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function generateEntityQuery(entity) {
+  const lines = [];
+  const queryType = entity.queryType;
+  lines.push(`struct ${entity.name}Query: EntityQuery {`);
+  lines.push(
+    `    func entities(for identifiers: [${entity.name}.ID]) async throws -> [${entity.name}] {`
+  );
+  lines.push(`        // TODO: Fetch entities by IDs`);
+  lines.push(`        return []`);
+  lines.push(`    }`);
+  lines.push(``);
+  if (queryType === "all") {
+    lines.push(`    func allEntities() async throws -> [${entity.name}] {`);
+    lines.push(`        // TODO: Return all entities`);
+    lines.push(`        return []`);
+    lines.push(`    }`);
+  } else if (queryType === "id") {
+    lines.push(`    // ID-based query is provided by the entities(for:) method above`);
+  } else if (queryType === "string") {
+    lines.push(
+      `    func entities(matching string: String) async throws -> [${entity.name}] {`
+    );
+    lines.push(`        // TODO: Search entities by string`);
+    lines.push(`        return []`);
+    lines.push(`    }`);
+  } else if (queryType === "property") {
+    lines.push(`    // Property-based query: implement using EntityPropertyQuery`);
+    lines.push(`    // Example: property.where { \\$0.status == "active" }`);
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
 function generateInfoPlistFragment(intent) {
   const keys = intent.infoPlistKeys;
   if (!keys || Object.keys(keys).length === 0) return void 0;
   const lines = [];
   lines.push(`<?xml version="1.0" encoding="UTF-8"?>`);
-  lines.push(
-    `<!-- Info.plist fragment generated by Axint for ${intent.name}Intent -->`
-  );
+  lines.push(`<!-- Info.plist fragment generated by Axint for ${intent.name}Intent -->`);
   lines.push(`<!-- Merge these keys into your app's Info.plist. -->`);
   lines.push(`<plist version="1.0">`);
   lines.push(`<dict>`);
@@ -507,7 +758,10 @@ function generateParameter(param) {
   lines.push(``);
   return lines.join("\n");
 }
-function generateReturnSignature(type) {
+function generateReturnSignature(type, customResultType) {
+  if (customResultType) {
+    return customResultType;
+  }
   if (type.kind === "primitive") {
     const swift = irTypeToSwift(type);
     return `some IntentResult & ReturnsValue<${swift}>`;
@@ -518,8 +772,11 @@ function generateReturnSignature(type) {
   }
   return `some IntentResult`;
 }
-function generatePerformReturn(type) {
+function generatePerformReturn(type, customResultType) {
   const indent = "        ";
+  if (customResultType) {
+    return `${indent}// TODO: Return a ${customResultType} instance`;
+  }
   if (type.kind === "primitive") {
     return `${indent}return .result(value: ${defaultLiteralFor(type.value)})`;
   }
@@ -664,6 +921,54 @@ function validateIntent(intent) {
       });
     }
   }
+  if (intent.entities) {
+    for (const entity of intent.entities) {
+      diagnostics.push(...validateEntity(entity, intent.sourceFile));
+    }
+  }
+  return diagnostics;
+}
+function validateEntity(entity, sourceFile) {
+  const diagnostics = [];
+  if (!entity.name || !/^[A-Z][a-zA-Z0-9]*$/.test(entity.name)) {
+    diagnostics.push({
+      code: "AX110",
+      severity: "error",
+      message: `Entity name "${entity.name}" must be PascalCase (e.g., "Task", "Playlist")`,
+      file: sourceFile,
+      suggestion: `Rename to "${toPascalCase(entity.name)}"`
+    });
+  }
+  if (entity.properties.length === 0) {
+    diagnostics.push({
+      code: "AX111",
+      severity: "error",
+      message: `Entity "${entity.name}" must have at least one property`,
+      file: sourceFile,
+      suggestion: "Add properties to define the entity's structure"
+    });
+  }
+  const titleProp = entity.displayRepresentation.title;
+  const propertyNames = new Set(entity.properties.map((p) => p.name));
+  if (titleProp && !propertyNames.has(titleProp)) {
+    diagnostics.push({
+      code: "AX112",
+      severity: "warning",
+      message: `Display title "${titleProp}" does not reference an existing property`,
+      file: sourceFile,
+      suggestion: `Available properties: ${[...propertyNames].join(", ")}`
+    });
+  }
+  const validQueryTypes = ["all", "id", "string", "property"];
+  if (!validQueryTypes.includes(entity.queryType)) {
+    diagnostics.push({
+      code: "AX113",
+      severity: "error",
+      message: `Entity query type "${entity.queryType}" is not valid`,
+      file: sourceFile,
+      suggestion: `Use one of: ${validQueryTypes.join(", ")}`
+    });
+  }
   return diagnostics;
 }
 function validateSwiftSource(swift) {
@@ -698,7 +1003,6 @@ function toPascalCase(s) {
 
 // src/core/compiler.ts
 function compileSource(source, fileName = "<stdin>", options = {}) {
-  const diagnostics = [];
   let ir;
   try {
     ir = parseIntentSource(source, fileName);
@@ -720,6 +1024,10 @@ function compileSource(source, fileName = "<stdin>", options = {}) {
     }
     throw err;
   }
+  return compileFromIR(ir, options);
+}
+function compileFromIR(ir, options = {}) {
+  const diagnostics = [];
   const irDiagnostics = validateIntent(ir);
   diagnostics.push(...irDiagnostics);
   if (irDiagnostics.some((d) => d.severity === "error")) {
@@ -780,7 +1088,7 @@ ${paramLines.join("\n")}
   lines.push(` * Generated by axint_scaffold. Edit freely, then run:`);
   lines.push(` *   npx axint compile src/intents/${kebab(name)}.ts`);
   lines.push(` */`);
-  lines.push(`import { defineIntent, param } from "axint";`);
+  lines.push(`import { defineIntent, param } from "@axintai/compiler";`);
   lines.push(``);
   lines.push(`export default defineIntent({`);
   lines.push(`  name: ${JSON.stringify(name)},`);
@@ -828,7 +1136,7 @@ var sendMessage = {
   domain: "messaging",
   category: "messaging",
   description: "Send a text message to a contact.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "SendMessage",
@@ -853,7 +1161,7 @@ var createEvent = {
   domain: "productivity",
   category: "productivity",
   description: "Create a calendar event with a title, date, and duration.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "CreateEvent",
@@ -883,7 +1191,7 @@ var bookRide = {
   domain: "navigation",
   category: "navigation",
   description: "Request a ride from a pickup location to a destination.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "BookRide",
@@ -908,7 +1216,7 @@ var getDirections = {
   domain: "navigation",
   category: "navigation",
   description: "Get turn-by-turn directions to a destination.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "GetDirections",
@@ -934,7 +1242,7 @@ var playTrack = {
   domain: "media",
   category: "media",
   description: "Play a specific track or song.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "PlayTrack",
@@ -959,7 +1267,7 @@ var createNote = {
   domain: "productivity",
   category: "productivity",
   description: "Create a new note with a title and body.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "CreateNote",
@@ -984,7 +1292,7 @@ var logExpense = {
   domain: "finance",
   category: "finance",
   description: "Log a financial expense with amount, category, and note.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "LogExpense",
@@ -1012,7 +1320,7 @@ var logWorkout = {
   domain: "health",
   category: "health",
   description: "Log a workout with duration, type, and calories burned.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "LogWorkout",
@@ -1042,7 +1350,7 @@ var setThermostat = {
   domain: "smart-home",
   category: "smart-home",
   description: "Set a smart-home thermostat to a target temperature.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "SetThermostat",
@@ -1067,7 +1375,7 @@ var placeOrder = {
   domain: "commerce",
   category: "commerce",
   description: "Place a commerce order for a product.",
-  source: `import { defineIntent, param } from "axint";
+  source: `import { defineIntent, param } from "@axintai/compiler";
 
 export default defineIntent({
   name: "PlaceOrder",
@@ -1085,6 +1393,73 @@ export default defineIntent({
 });
 `
 };
+var searchTasks = {
+  id: "search-tasks",
+  name: "search-tasks",
+  title: "Search Tasks",
+  domain: "productivity",
+  category: "productivity",
+  description: "Search for tasks using EntityQuery with string-based search.",
+  source: `import { defineIntent, defineEntity, param } from "@axintai/compiler";
+
+defineEntity({
+  name: "Task",
+  display: {
+    title: "name",
+    subtitle: "status",
+  },
+  properties: {
+    id: param.string("Unique task identifier"),
+    name: param.string("Task name"),
+    status: param.string("Task status (todo, in-progress, done)"),
+    dueDate: param.date("Due date"),
+  },
+  query: "string",
+});
+
+export default defineIntent({
+  name: "SearchTasks",
+  title: "Search Tasks",
+  description: "Search for tasks by name or status.",
+  domain: "productivity",
+  params: {
+    query: param.string("Search query"),
+    status: param.string("Filter by status (optional)", { required: false }),
+  },
+  donateOnPerform: true,
+  perform: async ({ query, status }) => {
+    // TODO: Search your task database with the query
+    // Use status filter if provided
+    return { found: true, results: 0 };
+  },
+});
+`
+};
+var dynamicPlaylist = {
+  id: "dynamic-playlist",
+  name: "dynamic-playlist",
+  title: "Dynamic Playlist",
+  domain: "media",
+  category: "media",
+  description: "Create a playlist by name, mood, and track count.",
+  source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "DynamicPlaylist",
+  title: "Create Dynamic Playlist",
+  description: "Create a playlist with a given mood or genre.",
+  domain: "media",
+  params: {
+    name: param.string("Playlist name"),
+    mood: param.string("Mood or genre (e.g., chill, workout, focus)"),
+    trackCount: param.int("Number of tracks", { default: 20 }),
+  },
+  perform: async ({ name, mood }) => {
+    return { playlistId: "playlist_placeholder" };
+  },
+});
+`
+};
 var TEMPLATES = [
   sendMessage,
   createEvent,
@@ -1095,7 +1470,9 @@ var TEMPLATES = [
   logExpense,
   logWorkout,
   setThermostat,
-  placeOrder
+  placeOrder,
+  searchTasks,
+  dynamicPlaylist
 ];
 function getTemplate(id) {
   return TEMPLATES.find((t) => t.id === id);