fix: add legacy prompt support with tool function resolution

Author: parkerhendo

scripts/functions-runner.ts

@@ -30,6 +30,22 @@ type CodeRegistryItem = {
 type EventRegistryItem = {
   project?: ProjectRef;
   toFunctionDefinition?: (resolver: Resolver) => Promise<JsonObject>;
+  name?: string;
+  slug?: string;
+  description?: string;
+  ifExists?: string;
+  metadata?: JsonValue;
+  prompt?: JsonValue;
+  toolFunctions?: LegacyToolFunction[];
+};
+
+type LegacyToolFunction = {
+  type?: string;
+  id?: string;
+  name?: string;
+  slug?: string;
+  project?: ProjectRef;
+  project_id?: string;
 };
 
 type CodeEntry = {
@@ -101,6 +117,7 @@ function currentRegistry(fallback: EvalRegistry): EvalRegistry {
 
 async function collectFunctionEvents(
   items: EventRegistryItem[],
+  includeLegacyPrompts: boolean,
 ): Promise<FunctionEventEntry[]> {
   const entries: FunctionEventEntry[] = [];
 
@@ -113,6 +130,12 @@ async function collectFunctionEvents(
 
   for (const item of items) {
     if (!item.toFunctionDefinition) {
+      if (includeLegacyPrompts) {
+        const entry = await collectLegacyPromptEvent(item, resolver);
+        if (entry) {
+          entries.push(entry);
+        }
+      }
       continue;
     }
 
@@ -141,6 +164,107 @@ async function collectFunctionEvents(
   return entries;
 }
 
+async function collectLegacyPromptEvent(
+  item: EventRegistryItem,
+  resolver: Resolver,
+): Promise<FunctionEventEntry | null> {
+  if (typeof item.name !== "string" || typeof item.slug !== "string") {
+    return null;
+  }
+
+  const normalizedPrompt = toJsonValue(item.prompt ?? {});
+  if (!isJsonObject(normalizedPrompt)) {
+    return null;
+  }
+
+  const promptData: JsonObject = { ...normalizedPrompt };
+  const toolFunctions = Array.isArray(item.toolFunctions)
+    ? item.toolFunctions
+    : [];
+  if (toolFunctions.length > 0) {
+    const resolvedTools: JsonValue[] = [];
+    for (const tool of toolFunctions) {
+      const resolved = await resolveLegacyToolFunction(tool, resolver);
+      if (resolved) {
+        resolvedTools.push(resolved);
+      }
+    }
+    if (resolvedTools.length > 0) {
+      promptData.tool_functions = resolvedTools;
+    }
+  }
+
+  const selector = asProjectSelector(item.project);
+  const projectId =
+    typeof selector.project_id === "string" ? selector.project_id : undefined;
+  const projectName =
+    typeof selector.project_name === "string"
+      ? selector.project_name
+      : undefined;
+
+  const event: JsonObject = {
+    name: item.name,
+    slug: item.slug,
+    description: typeof item.description === "string" ? item.description : "",
+    function_data: {
+      type: "prompt",
+    },
+    prompt_data: promptData,
+  };
+  if (typeof item.ifExists === "string") {
+    event.if_exists = item.ifExists;
+  }
+  if (item.metadata !== undefined) {
+    event.metadata = item.metadata;
+  }
+
+  return {
+    kind: "function_event",
+    project_id: projectId,
+    project_name: projectName,
+    event,
+  };
+}
+
+async function resolveLegacyToolFunction(
+  tool: LegacyToolFunction,
+  resolver: Resolver,
+): Promise<JsonObject | null> {
+  if (
+    typeof tool.slug === "string" &&
+    tool.slug.length > 0 &&
+    tool.project !== undefined
+  ) {
+    const projectId = await resolver.resolve(tool.project);
+    if (projectId.length > 0) {
+      return {
+        type: "slug",
+        project_id: projectId,
+        slug: tool.slug,
+      };
+    }
+  }
+
+  const direct: JsonObject = {};
+  if (typeof tool.type === "string") {
+    direct.type = tool.type;
+  }
+  if (typeof tool.id === "string") {
+    direct.id = tool.id;
+  }
+  if (typeof tool.name === "string") {
+    direct.name = tool.name;
+  }
+  if (typeof tool.project_id === "string") {
+    direct.project_id = tool.project_id;
+  }
+  if (typeof tool.slug === "string") {
+    direct.slug = tool.slug;
+  }
+
+  return Object.keys(direct).length > 0 ? direct : null;
+}
+
 function collectCodeEntries(items: CodeRegistryItem[]): CodeEntry[] {
   const entries: CodeEntry[] = [];
 
@@ -197,9 +321,13 @@ async function processFile(filePath: string): Promise<ManifestFile> {
 
   const entries: Array<CodeEntry | FunctionEventEntry> = [
     ...collectCodeEntries(registry.functions as CodeRegistryItem[]),
-    ...(await collectFunctionEvents(registry.prompts as EventRegistryItem[])),
+    ...(await collectFunctionEvents(
+      registry.prompts as EventRegistryItem[],
+      true,
+    )),
     ...(await collectFunctionEvents(
       registry.parameters as EventRegistryItem[],
+      false,
     )),
   ];
 

src/functions/push.rs

@@ -848,6 +848,7 @@ async fn push_file(
                     Value::String(args.if_exists.as_str().to_string()),
                 );
             }
+            default_prompt_function_type(object);
         }
 
         function_events.push(event);
@@ -962,6 +963,36 @@ fn calculate_upload_counts(total_entries: usize, ignored_entries: Option<usize>)
     (uploaded_entries, ignored_entries)
 }
 
+fn default_prompt_function_type(event: &mut Map<String, Value>) {
+    if !is_prompt_function_event(event) {
+        return;
+    }
+
+    if function_type_missing_or_empty(event.get("function_type")) {
+        event.insert(
+            "function_type".to_string(),
+            Value::String("prompt".to_string()),
+        );
+    }
+}
+
+fn is_prompt_function_event(event: &Map<String, Value>) -> bool {
+    event
+        .get("function_data")
+        .and_then(Value::as_object)
+        .and_then(|function_data| function_data.get("type"))
+        .and_then(Value::as_str)
+        == Some("prompt")
+}
+
+fn function_type_missing_or_empty(value: Option<&Value>) -> bool {
+    match value {
+        None | Some(Value::Null) => true,
+        Some(Value::String(s)) => s.trim().is_empty(),
+        Some(_) => false,
+    }
+}
+
 fn run_functions_runner(
     args: &PushArgs,
     files: &[PathBuf],
@@ -2848,6 +2879,61 @@ mod tests {
         assert_eq!(calculate_upload_counts(3, None), (3, 0));
     }
 
+    #[test]
+    fn prompt_event_defaults_function_type_when_missing() {
+        let mut event = Map::new();
+        event.insert(
+            "function_data".to_string(),
+            serde_json::json!({
+                "type": "prompt"
+            }),
+        );
+
+        default_prompt_function_type(&mut event);
+
+        assert_eq!(
+            event.get("function_type"),
+            Some(&Value::String("prompt".to_string()))
+        );
+    }
+
+    #[test]
+    fn prompt_event_preserves_existing_function_type() {
+        let mut event = Map::new();
+        event.insert(
+            "function_data".to_string(),
+            serde_json::json!({
+                "type": "prompt"
+            }),
+        );
+        event.insert(
+            "function_type".to_string(),
+            Value::String("scorer".to_string()),
+        );
+
+        default_prompt_function_type(&mut event);
+
+        assert_eq!(
+            event.get("function_type"),
+            Some(&Value::String("scorer".to_string()))
+        );
+    }
+
+    #[test]
+    fn non_prompt_event_does_not_default_function_type() {
+        let mut event = Map::new();
+        event.insert(
+            "function_data".to_string(),
+            serde_json::json!({
+                "type": "code"
+            }),
+        );
+
+        default_prompt_function_type(&mut event);
+
+        assert!(!event.contains_key("function_type"));
+    }
+
     #[test]
     fn requirements_reference_escape_is_rejected() {
         let dir = tempfile::tempdir().expect("tempdir");